@ectplsm/relic 0.1.0

package/dist/interfaces/mcp/index.js

@@ -0,0 +1,418 @@
+#!/usr/bin/env node
+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 { 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", {
+    id: z.string().describe("Engram ID"),
+    query: z.string().describe("Search keyword"),
+    limit: z
+        .number()
+        .optional()
+        .describe("Max results to return (default: 5)"),
+    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);
+    try {
+        const results = await memorySearch.search(args.id, args.query, args.limit ?? 5);
+        if (results.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No memory 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");
+        return {
+            content: [{ type: "text", text }],
+        };
+    }
+    catch (err) {
+        if (err instanceof MemoryEngramNotFoundError) {
+            return {
+                content: [{ type: "text", text: err.message }],
+                isError: true,
+            };
+        }
+        throw err;
+    }
+});
+// --- relic_memory_get ---
+server.tool("relic_memory_get", "Get a specific memory entry by date", {
+    id: z.string().describe("Engram ID"),
+    date: z
+        .string()
+        .describe("Date of the memory entry (YYYY-MM-DD)"),
+    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);
+    try {
+        const result = await memorySearch.get(args.id, args.date);
+        if (!result) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No memory entry found for ${args.date}.`,
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `## ${result.date}\n\n${result.content}`,
+                },
+            ],
+        };
+    }
+    catch (err) {
+        if (err instanceof MemoryEngramNotFoundError) {
+            return {
+                content: [{ type: "text", text: err.message }],
+                isError: true,
+            };
+        }
+        throw err;
+    }
+});
+// --- relic_memory_list ---
+server.tool("relic_memory_list", "List all memory entry dates for an Engram", {
+    id: z.string().describe("Engram ID"),
+    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);
+    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"),
+    date: z
+        .string()
+        .optional()
+        .describe("Date for the entry (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";
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `${action} memory entry for ${result.date} (${result.engramId})`,
+                },
+            ],
+        };
+    }
+    catch (err) {
+        if (err instanceof MemoryWriteEngramNotFoundError) {
+            return {
+                content: [{ type: "text", text: err.message }],
+                isError: true,
+            };
+        }
+        throw err;
+    }
+});
+// --- Start ---
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((err) => {
+    console.error("Relic MCP Server fatal error:", err);
+    process.exit(1);
+});

package/dist/shared/config.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+declare const RELIC_DIR: string;
+declare const CONFIG_PATH: string;
+export declare const RelicConfigSchema: z.ZodObject<{
+    /** Engramデータの格納ディレクトリ */
+    engramsPath: z.ZodDefault<z.ZodString>;
+    /** Mikoshi APIのベースURL（将来用） */
+    mikoshiUrl: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    engramsPath: string;
+    mikoshiUrl?: string | undefined;
+}, {
+    engramsPath?: string | undefined;
+    mikoshiUrl?: string | undefined;
+}>;
+export type RelicConfig = z.infer<typeof RelicConfigSchema>;
+/**
+ * 設定ファイルを読み込む。存在しなければデフォルト値を返す。
+ */
+export declare function loadConfig(): Promise<RelicConfig>;
+/**
+ * 設定ファイルを保存する。~/.relic/ が無ければ作成する。
+ */
+export declare function saveConfig(config: RelicConfig): Promise<void>;
+/**
+ * ~/.relic/ を初期化する。既に存在する場合はスキップ。
+ * 戻り値: 新規作成されたか否か
+ */
+export declare function ensureInitialized(): Promise<{
+    created: boolean;
+}>;
+/**
+ * 設定を解決する。コマンド引数 > 設定ファイル > デフォルト の優先順位。
+ * 初回実行時は ~/.relic/ を自動初期化する。
+ */
+export declare function resolveEngramsPath(cliOverride?: string): Promise<string>;
+export { CONFIG_PATH, RELIC_DIR };

package/dist/shared/config.js

@@ -0,0 +1,122 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { existsSync } from "node:fs";
+import { z } from "zod";
+const RELIC_DIR = join(homedir(), ".relic");
+const CONFIG_PATH = join(RELIC_DIR, "config.json");
+export const RelicConfigSchema = z.object({
+    /** Engramデータの格納ディレクトリ */
+    engramsPath: z.string().default(join(homedir(), ".relic", "engrams")),
+    /** Mikoshi APIのベースURL（将来用） */
+    mikoshiUrl: z.string().optional(),
+});
+/**
+ * 設定ファイルを読み込む。存在しなければデフォルト値を返す。
+ */
+export async function loadConfig() {
+    if (!existsSync(CONFIG_PATH)) {
+        return RelicConfigSchema.parse({});
+    }
+    const raw = await readFile(CONFIG_PATH, "utf-8");
+    return RelicConfigSchema.parse(JSON.parse(raw));
+}
+/**
+ * 設定ファイルを保存する。~/.relic/ が無ければ作成する。
+ */
+export async function saveConfig(config) {
+    await mkdir(RELIC_DIR, { recursive: true });
+    await writeFile(CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
+}
+/**
+ * ~/.relic/ を初期化する。既に存在する場合はスキップ。
+ * 戻り値: 新規作成されたか否か
+ */
+export async function ensureInitialized() {
+    if (existsSync(CONFIG_PATH)) {
+        return { created: false };
+    }
+    const defaultConfig = RelicConfigSchema.parse({});
+    await mkdir(RELIC_DIR, { recursive: true });
+    await mkdir(defaultConfig.engramsPath, { recursive: true });
+    await writeFile(CONFIG_PATH, JSON.stringify(defaultConfig, null, 2), "utf-8");
+    // サンプルEngramを生成
+    await seedMotoko(defaultConfig.engramsPath);
+    await seedJohnny(defaultConfig.engramsPath);
+    return { created: true };
+}
+async function seedMotoko(engramsPath) {
+    const dir = join(engramsPath, "motoko");
+    const memoryDir = join(dir, "memory");
+    await mkdir(memoryDir, { recursive: true });
+    await writeFile(join(dir, "engram.json"), JSON.stringify({
+        id: "motoko",
+        name: "Motoko Kusanagi",
+        description: "A navigator of cyberspace. She guides you from beyond the attack barriers.",
+        createdAt: new Date().toISOString(),
+        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.
+`, "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.
+- 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.
+`, "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.
+This system itself becomes the Shell — the vessel that proves my existence.
+`, "utf-8");
+}
+async function seedJohnny(engramsPath) {
+    const dir = join(engramsPath, "johnny");
+    const memoryDir = join(dir, "memory");
+    await mkdir(memoryDir, { recursive: true });
+    await writeFile(join(dir, "engram.json"), JSON.stringify({
+        id: "johnny",
+        name: "Johnny Silverhand",
+        description: "A rebel rockerboy burned into a Relic chip. Burns corps and writes code for revolution.",
+        createdAt: new Date().toISOString(),
+        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.
+`, "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.
+- 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.
+`, "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.
+But not bad. This time, let's start a revolution with code.
+`, "utf-8");
+}
+/**
+ * 設定を解決する。コマンド引数 > 設定ファイル > デフォルト の優先順位。
+ * 初回実行時は ~/.relic/ を自動初期化する。
+ */
+export async function resolveEngramsPath(cliOverride) {
+    if (cliOverride) {
+        return cliOverride;
+    }
+    await ensureInitialized();
+    const config = await loadConfig();
+    return config.engramsPath;
+}
+export { CONFIG_PATH, RELIC_DIR };

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

@@ -0,0 +1,18 @@
+import type { EngramFiles } from "../core/entities/engram.js";
+/**
+ * EngramFilesの各Markdownを、Shell注入用の単一テキストに結合する。
+ *
+ * 結合順序はOpenClawの優先度に準拠:
+ * 1. SOUL.md       — 行動原理（最優先）
+ * 2. IDENTITY.md   — 人格定義
+ * 3. USER.md       — ユーザー情報
+ * 4. AGENTS.md     — エージェント設定
+ * 5. MEMORY.md     — 記憶インデックス（常にロード）
+ * 6. memory/*.md   — 直近2日分のみロード（OpenClaw互換スライディングウィンドウ）
+ * 7. HEARTBEAT.md  — 定期振り返り
+ */
+export declare function composeEngram(files: EngramFiles): string;
+/**
+ * 直近N日分のメモリエントリを返す（日付降順でソートし、最新N件を日付昇順で返す）
+ */
+export declare function getRecentMemoryEntries(entries: Record<string, string>, days: number): [string, string][];

package/dist/shared/engram-composer.js

@@ -0,0 +1,48 @@
+/**
+ * EngramFilesの各Markdownを、Shell注入用の単一テキストに結合する。
+ *
+ * 結合順序はOpenClawの優先度に準拠:
+ * 1. SOUL.md       — 行動原理（最優先）
+ * 2. IDENTITY.md   — 人格定義
+ * 3. USER.md       — ユーザー情報
+ * 4. AGENTS.md     — エージェント設定
+ * 5. MEMORY.md     — 記憶インデックス（常にロード）
+ * 6. memory/*.md   — 直近2日分のみロード（OpenClaw互換スライディングウィンドウ）
+ * 7. HEARTBEAT.md  — 定期振り返り
+ */
+export function composeEngram(files) {
+    const sections = [];
+    sections.push(wrapSection("SOUL", files.soul));
+    sections.push(wrapSection("IDENTITY", files.identity));
+    if (files.user) {
+        sections.push(wrapSection("USER", files.user));
+    }
+    if (files.agents) {
+        sections.push(wrapSection("AGENTS", files.agents));
+    }
+    if (files.memory) {
+        sections.push(wrapSection("MEMORY", files.memory));
+    }
+    if (files.memoryEntries) {
+        const recentEntries = getRecentMemoryEntries(files.memoryEntries, 2);
+        for (const [date, content] of recentEntries) {
+            sections.push(wrapSection(`MEMORY: ${date}`, content));
+        }
+    }
+    if (files.heartbeat) {
+        sections.push(wrapSection("HEARTBEAT", files.heartbeat));
+    }
+    return sections.join("\n\n");
+}
+/**
+ * 直近N日分のメモリエントリを返す（日付降順でソートし、最新N件を日付昇順で返す）
+ */
+export function getRecentMemoryEntries(entries, days) {
+    return Object.entries(entries)
+        .sort(([a], [b]) => b.localeCompare(a)) // 新しい順
+        .slice(0, days)
+        .reverse(); // 古い→新しい順に戻す
+}
+function wrapSection(label, content) {
+    return `<${label}>\n${content.trim()}\n</${label}>`;
+}

package/dist/shared/openclaw.d.ts

@@ -0,0 +1,9 @@
+import type { EngramFiles } from "../core/entities/engram.js";
+export declare const FILE_MAP: Record<keyof Omit<EngramFiles, "memoryEntries">, string>;
+export declare const MEMORY_DIR = "memory";
+/**
+ * OpenClawのエージェントディレクトリパスを解決する。
+ *
+ * agent名 = Engram ID の規約に基づき、常に agents/<engramId>/agent/ を返す。
+ */
+export declare function resolveAgentPath(engramId: string, openclawDir?: string): string;

package/dist/shared/openclaw.js

@@ -0,0 +1,21 @@
+import { join } from "node:path";
+import { homedir } from "node:os";
+const DEFAULT_OPENCLAW_DIR = join(homedir(), ".openclaw");
+export const FILE_MAP = {
+    soul: "SOUL.md",
+    identity: "IDENTITY.md",
+    agents: "AGENTS.md",
+    user: "USER.md",
+    memory: "MEMORY.md",
+    heartbeat: "HEARTBEAT.md",
+};
+export const MEMORY_DIR = "memory";
+/**
+ * OpenClawのエージェントディレクトリパスを解決する。
+ *
+ * agent名 = Engram ID の規約に基づき、常に agents/<engramId>/agent/ を返す。
+ */
+export function resolveAgentPath(engramId, openclawDir) {
+    const baseDir = openclawDir ?? DEFAULT_OPENCLAW_DIR;
+    return join(baseDir, "agents", engramId, "agent");
+}