@ectplsm/relic 0.2.1 → 0.2.3

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

@@ -1,6 +1,8 @@
 export { Summon, EngramNotFoundError, type SummonResult } from "./summon.js";
 export { ListEngrams } from "./list-engrams.js";
 export { Init, type InitResult } from "./init.js";
+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";

package/dist/core/usecases/index.js

@@ -1,6 +1,8 @@
 export { Summon, EngramNotFoundError } from "./summon.js";
 export { ListEngrams } from "./list-engrams.js";
 export { Init } from "./init.js";
+export { MigrateEngrams, } from "./migrate-engrams.js";
+export { RefreshSamples, } from "./refresh-samples.js";
 export { Inject, InjectEngramNotFoundError, InjectClawDirNotFoundError, InjectWorkspaceNotFoundError, } from "./inject.js";
 export { Extract, WorkspaceNotFoundError, WorkspaceEmptyError, AlreadyExtractedError, } from "./extract.js";
 export { MemoryWrite, MemoryWriteEngramNotFoundError, } from "./memory-write.js";

package/dist/core/usecases/migrate-engrams.d.ts

@@ -0,0 +1,18 @@
+import type { EngramRepository } from "../ports/engram-repository.js";
+export interface MigrateEngramsResult {
+    migrated: string[];
+    alreadyUpToDate: string[];
+    skipped: Array<{
+        id: string;
+        reason: string;
+    }>;
+}
+/**
+ * MigrateEngrams — 既存Engramを走査し、新形式の manifest.json へ前倒し移行する
+ */
+export declare class MigrateEngrams {
+    private readonly repository;
+    private readonly basePath;
+    constructor(repository: EngramRepository, basePath: string);
+    execute(): Promise<MigrateEngramsResult>;
+}

package/dist/core/usecases/migrate-engrams.js

@@ -0,0 +1,49 @@
+import { existsSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+/**
+ * MigrateEngrams — 既存Engramを走査し、新形式の manifest.json へ前倒し移行する
+ */
+export class MigrateEngrams {
+    repository;
+    basePath;
+    constructor(repository, basePath) {
+        this.repository = repository;
+        this.basePath = basePath;
+    }
+    async execute() {
+        if (!existsSync(this.basePath)) {
+            return { migrated: [], alreadyUpToDate: [], skipped: [] };
+        }
+        const entries = await readdir(this.basePath, { withFileTypes: true });
+        const dirs = entries.filter((entry) => entry.isDirectory());
+        const result = {
+            migrated: [],
+            alreadyUpToDate: [],
+            skipped: [],
+        };
+        for (const dir of dirs) {
+            const id = dir.name;
+            const engramDir = join(this.basePath, id);
+            const profilePath = join(engramDir, "engram.json");
+            const manifestPath = join(engramDir, "manifest.json");
+            if (!existsSync(profilePath)) {
+                result.skipped.push({ id, reason: "engram.json not found" });
+                continue;
+            }
+            const hadManifest = existsSync(manifestPath);
+            const engram = await this.repository.get(id);
+            if (!engram) {
+                result.skipped.push({ id, reason: "failed to load engram metadata" });
+                continue;
+            }
+            if (!hadManifest && existsSync(manifestPath)) {
+                result.migrated.push(id);
+            }
+            else {
+                result.alreadyUpToDate.push(id);
+            }
+        }
+        return result;
+    }
+}

package/dist/core/usecases/refresh-samples.d.ts

@@ -0,0 +1,21 @@
+import type { EngramRepository } from "../ports/engram-repository.js";
+export interface RefreshSamplesResult {
+    refreshed: string[];
+    skipped: Array<{
+        id: string;
+        reason: string;
+    }>;
+}
+/**
+ * RefreshSamples — サンプルEngramの人格ファイルを最新テンプレートで上書きする
+ *
+ * memory / USER / archive などの運用データは保持し、
+ * SOUL.md / IDENTITY.md と updatedAt のみを更新する。
+ */
+export declare class RefreshSamples {
+    private readonly repository;
+    private readonly templatesDir;
+    constructor(repository: EngramRepository, templatesDir: string);
+    execute(targetIds?: string[]): Promise<RefreshSamplesResult>;
+    private listTemplateIds;
+}

package/dist/core/usecases/refresh-samples.js

@@ -0,0 +1,60 @@
+import { existsSync } from "node:fs";
+import { readFile, readdir } from "node:fs/promises";
+import { join } from "node:path";
+/**
+ * RefreshSamples — サンプルEngramの人格ファイルを最新テンプレートで上書きする
+ *
+ * memory / USER / archive などの運用データは保持し、
+ * SOUL.md / IDENTITY.md と updatedAt のみを更新する。
+ */
+export class RefreshSamples {
+    repository;
+    templatesDir;
+    constructor(repository, templatesDir) {
+        this.repository = repository;
+        this.templatesDir = templatesDir;
+    }
+    async execute(targetIds) {
+        const ids = targetIds && targetIds.length > 0
+            ? targetIds
+            : await this.listTemplateIds();
+        const result = {
+            refreshed: [],
+            skipped: [],
+        };
+        for (const id of ids) {
+            const templateDir = join(this.templatesDir, id);
+            if (!existsSync(templateDir)) {
+                result.skipped.push({ id, reason: "sample template not found" });
+                continue;
+            }
+            const engram = await this.repository.get(id);
+            if (!engram) {
+                result.skipped.push({ id, reason: "local Engram not found" });
+                continue;
+            }
+            const soulPath = join(templateDir, "SOUL.md");
+            const identityPath = join(templateDir, "IDENTITY.md");
+            if (!existsSync(soulPath) || !existsSync(identityPath)) {
+                result.skipped.push({ id, reason: "template persona files are incomplete" });
+                continue;
+            }
+            engram.files.soul = await readFile(soulPath, "utf-8");
+            engram.files.identity = await readFile(identityPath, "utf-8");
+            engram.meta.updatedAt = new Date().toISOString();
+            await this.repository.save(engram);
+            result.refreshed.push(id);
+        }
+        return result;
+    }
+    async listTemplateIds() {
+        if (!existsSync(this.templatesDir)) {
+            return [];
+        }
+        const entries = await readdir(this.templatesDir, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort();
+    }
+}

package/dist/interfaces/cli/commands/create.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerCreateCommand(program: Command): void;

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

@@ -0,0 +1,143 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { loadConfig, ensureInitialized } from "../../../shared/config.js";
+import { LocalEngramRepository } from "../../../adapters/local/index.js";
+import { DEFAULT_SOUL, DEFAULT_IDENTITY } from "../../../shared/templates.js";
+import { CreateEngram, EngramAlreadyExistsError, InvalidEngramIdError, ENGRAM_ID_PATTERN, } from "../../../core/usecases/create-engram.js";
+// ============================================================
+// Interactive prompt helpers
+// ============================================================
+async function ask(rl, question) {
+    const answer = await rl.question(question);
+    return answer.trim();
+}
+async function askRequired(rl, question, errorMsg) {
+    while (true) {
+        const answer = await ask(rl, question);
+        if (answer)
+            return answer;
+        console.log(errorMsg);
+    }
+}
+/**
+ * Ask for a valid, non-duplicate Engram ID. Retries on bad format or collision.
+ */
+async function askValidId(rl, repo) {
+    while (true) {
+        const id = await askRequired(rl, "Engram ID (e.g. my-agent): ", "  ID is required. Use lowercase letters, numbers, and hyphens.");
+        if (!ENGRAM_ID_PATTERN.test(id)) {
+            console.log("  Invalid ID. Use lowercase letters, numbers, and hyphens (e.g. my-agent).");
+            continue;
+        }
+        const existing = await repo.get(id);
+        if (existing) {
+            console.log(`  Engram "${id}" already exists. Choose a different ID.`);
+            continue;
+        }
+        return id;
+    }
+}
+// ============================================================
+// Command
+// ============================================================
+export function registerCreateCommand(program) {
+    program
+        .command("create")
+        .description("Create a new Engram interactively")
+        .option("-i, --id <id>", "Engram ID (lowercase alphanumeric + hyphens)")
+        .option("-n, --name <name>", "Display name")
+        .option("-d, --description <desc>", "Description")
+        .option("-t, --tags <tags>", "Comma-separated tags")
+        .action(async (opts) => {
+        await ensureInitialized();
+        const config = await loadConfig();
+        const repo = new LocalEngramRepository(config.engramsPath);
+        const usecase = new CreateEngram(repo);
+        const isTTY = input.isTTY && output.isTTY;
+        // If non-interactive, require at least id and name
+        if (!isTTY) {
+            if (!opts.id || !opts.name) {
+                console.error("Error: --id and --name are required in non-interactive mode.");
+                process.exitCode = 1;
+                return;
+            }
+        }
+        let id = opts.id;
+        let name = opts.name;
+        let description = opts.description;
+        let tags;
+        if (opts.tags) {
+            tags = opts.tags.split(",").map((t) => t.trim()).filter(Boolean);
+        }
+        // Early validation for pre-supplied ID (before interactive flow)
+        if (id) {
+            if (!ENGRAM_ID_PATTERN.test(id)) {
+                console.error(`Error: Invalid Engram ID "${id}". Use lowercase letters, numbers, and hyphens only (e.g. "my-agent").`);
+                process.exitCode = 1;
+                return;
+            }
+            const existing = await repo.get(id);
+            if (existing) {
+                console.error(`Error: Engram "${id}" already exists. Delete it first or choose a different ID.`);
+                process.exitCode = 1;
+                return;
+            }
+        }
+        // Interactive flow for missing fields
+        if (isTTY && (!id || !name)) {
+            const rl = createInterface({ input, output });
+            try {
+                if (!id) {
+                    id = await askValidId(rl, repo);
+                }
+                if (!name) {
+                    name = await askRequired(rl, "Name: ", "  Name is required.");
+                }
+                if (description === undefined) {
+                    description = await ask(rl, "Description (optional): ") || undefined;
+                }
+                if (tags === undefined) {
+                    const tagsInput = await ask(rl, "Tags (comma-separated, optional): ");
+                    if (tagsInput) {
+                        tags = tagsInput.split(",").map((t) => t.trim()).filter(Boolean);
+                    }
+                }
+            }
+            finally {
+                rl.close();
+            }
+        }
+        // Execute
+        try {
+            const result = await usecase.execute({
+                id: id,
+                name: name,
+                description,
+                tags,
+                soul: DEFAULT_SOUL,
+                identity: DEFAULT_IDENTITY,
+            });
+            const green = (s) => `\x1b[32m${s}\x1b[0m`;
+            const engramDir = `${config.engramsPath}/${result.engram.meta.id}`;
+            console.log();
+            console.log(green(`Created Engram "${result.engram.meta.name}" (${result.engram.meta.id})`));
+            console.log(`  → ${engramDir}/`);
+            console.log();
+            console.log("Files:");
+            console.log("  engram.json    — metadata (name, description, tags)");
+            console.log("  manifest.json  — system metadata (id, timestamps)");
+            console.log("  SOUL.md        — core principles and behavior");
+            console.log("  IDENTITY.md    — persona identity (fill in during first conversation)");
+            console.log();
+            console.log(`Customize SOUL.md and IDENTITY.md, then run: relic claude ${result.engram.meta.id}`);
+        }
+        catch (err) {
+            if (err instanceof InvalidEngramIdError || err instanceof EngramAlreadyExistsError) {
+                console.error(`Error: ${err.message}`);
+                process.exitCode = 1;
+                return;
+            }
+            throw err;
+        }
+    });
+}

package/dist/interfaces/cli/commands/delete.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerDeleteCommand(program: Command): void;

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

@@ -0,0 +1,113 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { loadConfig, ensureInitialized } from "../../../shared/config.js";
+import { LocalEngramRepository } from "../../../adapters/local/index.js";
+import { DeleteEngram, DeleteEngramNotFoundError, } from "../../../core/usecases/delete-engram.js";
+// ============================================================
+// Helpers
+// ============================================================
+async function confirm(message) {
+    if (!input.isTTY || !output.isTTY)
+        return false;
+    const rl = createInterface({ input, output });
+    try {
+        const answer = await rl.question(message);
+        return /^(y|yes)$/i.test(answer.trim());
+    }
+    finally {
+        rl.close();
+    }
+}
+async function confirmWithId(message, expectedId) {
+    if (!input.isTTY || !output.isTTY)
+        return false;
+    const rl = createInterface({ input, output });
+    try {
+        const answer = await rl.question(message);
+        return answer.trim() === expectedId;
+    }
+    finally {
+        rl.close();
+    }
+}
+// ============================================================
+// Command
+// ============================================================
+export function registerDeleteCommand(program) {
+    program
+        .command("delete")
+        .description("Delete an Engram permanently")
+        .argument("<id>", "Engram ID to delete")
+        .option("-f, --force", "Skip confirmation prompts")
+        .action(async (id, opts) => {
+        await ensureInitialized();
+        const config = await loadConfig();
+        const repo = new LocalEngramRepository(config.engramsPath);
+        const usecase = new DeleteEngram(repo);
+        const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+        // Inspect
+        let info;
+        try {
+            info = await usecase.inspect(id);
+        }
+        catch (err) {
+            if (err instanceof DeleteEngramNotFoundError) {
+                console.error(`Error: ${err.message}`);
+                process.exitCode = 1;
+                return;
+            }
+            throw err;
+        }
+        // Check for archive.md separately (not in EngramFiles)
+        const archivePath = join(config.engramsPath, id, "archive.md");
+        const hasArchive = existsSync(archivePath);
+        const hasData = info.hasMemory || info.hasUser || hasArchive || info.memoryEntryCount > 0;
+        const displayName = `"${info.engram.meta.name}" (${id})`;
+        if (!opts.force) {
+            if (hasData) {
+                // Dangerous: has memory data — require ID confirmation
+                console.log();
+                console.log(yellow(`⚠ Engram ${displayName} has memory data:`));
+                const items = [];
+                if (info.hasMemory)
+                    items.push("MEMORY.md");
+                if (info.hasUser)
+                    items.push("USER.md");
+                if (info.memoryEntryCount > 0)
+                    items.push(`${info.memoryEntryCount} memory entries`);
+                if (hasArchive)
+                    items.push("archive.md");
+                console.log(`  ${items.join(", ")}`);
+                console.log();
+                const confirmed = await confirmWithId(`Delete permanently? This cannot be undone. (type "${id}" to confirm): `, id);
+                if (!confirmed) {
+                    console.log("Cancelled.");
+                    return;
+                }
+            }
+            else {
+                // Simple: no memory data — y/N is enough
+                const confirmed = await confirm(`Delete Engram ${displayName}? (y/N): `);
+                if (!confirmed) {
+                    console.log("Cancelled.");
+                    return;
+                }
+            }
+        }
+        // Execute deletion
+        try {
+            await usecase.execute(id);
+            console.log(`Deleted Engram ${displayName}`);
+        }
+        catch (err) {
+            if (err instanceof DeleteEngramNotFoundError) {
+                console.error(`Error: ${err.message}`);
+                process.exitCode = 1;
+                return;
+            }
+            throw err;
+        }
+    });
+}

package/dist/interfaces/cli/commands/migrate.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerMigrateCommand(program: Command): void;

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

@@ -0,0 +1,31 @@
+import { LocalEngramRepository } from "../../../adapters/local/index.js";
+import { MigrateEngrams } from "../../../core/usecases/index.js";
+import { resolveEngramsPath } from "../../../shared/config.js";
+export function registerMigrateCommand(program) {
+    const migrate = program
+        .command("migrate")
+        .description("Run one-off migrations for local Relic data");
+    migrate
+        .command("engrams")
+        .description("Migrate Engram metadata from legacy engram.json to manifest.json")
+        .option("-p, --path <dir>", "Override engrams directory path")
+        .action(async (opts) => {
+        const engramsPath = await resolveEngramsPath(opts.path);
+        const repo = new LocalEngramRepository(engramsPath);
+        const migrateEngrams = new MigrateEngrams(repo, engramsPath);
+        const result = await migrateEngrams.execute();
+        console.log(`Scanned Engrams: ${result.migrated.length + result.alreadyUpToDate.length + result.skipped.length}`);
+        console.log(`  Migrated: ${result.migrated.length}`);
+        console.log(`  Already up to date: ${result.alreadyUpToDate.length}`);
+        console.log(`  Skipped: ${result.skipped.length}`);
+        if (result.migrated.length > 0) {
+            console.log(`  Migrated IDs: ${result.migrated.join(", ")}`);
+        }
+        if (result.alreadyUpToDate.length > 0) {
+            console.log(`  Up-to-date IDs: ${result.alreadyUpToDate.join(", ")}`);
+        }
+        for (const skipped of result.skipped) {
+            console.log(`  Skipped ${skipped.id}: ${skipped.reason}`);
+        }
+    });
+}

package/dist/interfaces/cli/commands/refresh-samples.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerRefreshSamplesCommand(program: Command): void;

package/dist/interfaces/cli/commands/refresh-samples.js

@@ -0,0 +1,24 @@
+import { LocalEngramRepository } from "../../../adapters/local/index.js";
+import { RefreshSamples } from "../../../core/usecases/index.js";
+import { resolveEngramsPath, TEMPLATES_DIR } from "../../../shared/config.js";
+export function registerRefreshSamplesCommand(program) {
+    program
+        .command("refresh-samples")
+        .description("Refresh sample Engrams from the latest bundled templates")
+        .option("-e, --engram <id>", "Refresh one sample Engram only")
+        .option("-p, --path <dir>", "Override engrams directory path")
+        .action(async (opts) => {
+        const engramsPath = await resolveEngramsPath(opts.path);
+        const repo = new LocalEngramRepository(engramsPath);
+        const refreshSamples = new RefreshSamples(repo, TEMPLATES_DIR);
+        const result = await refreshSamples.execute(opts.engram ? [opts.engram] : undefined);
+        console.log(`Refreshed: ${result.refreshed.length}`);
+        if (result.refreshed.length > 0) {
+            console.log(`  IDs: ${result.refreshed.join(", ")}`);
+        }
+        console.log(`Skipped: ${result.skipped.length}`);
+        for (const skipped of result.skipped) {
+            console.log(`  ${skipped.id}: ${skipped.reason}`);
+        }
+    });
+}

package/dist/interfaces/cli/index.js

@@ -9,6 +9,10 @@ import { registerShowCommand } from "./commands/show.js";
 import { registerShellCommands } from "./commands/shell.js";
 import { registerClawCommand } from "./commands/claw.js";
 import { registerConfigCommand } from "./commands/config.js";
+import { registerMigrateCommand } from "./commands/migrate.js";
+import { registerRefreshSamplesCommand } from "./commands/refresh-samples.js";
+import { registerCreateCommand } from "./commands/create.js";
+import { registerDeleteCommand } from "./commands/delete.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(resolve(__dirname, "../../../package.json"), "utf-8"));
 const program = new Command();
@@ -17,9 +21,13 @@ program
     .description("PROJECT RELIC — Engram injection system for AI constructs")
     .version(pkg.version);
 registerInitCommand(program);
+registerCreateCommand(program);
+registerDeleteCommand(program);
 registerListCommand(program);
 registerShowCommand(program);
 registerShellCommands(program);
 registerClawCommand(program);
 registerConfigCommand(program);
+registerMigrateCommand(program);
+registerRefreshSamplesCommand(program);
 program.parse();

package/dist/interfaces/mcp/index.js

@@ -6,6 +6,9 @@ import { ArchiveSearch, ArchiveSearchEngramNotFoundError, } from "../../core/use
 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 { CreateEngram, EngramAlreadyExistsError, InvalidEngramIdError, } from "../../core/usecases/create-engram.js";
+import { DEFAULT_SOUL, DEFAULT_IDENTITY } from "../../shared/templates.js";
+import { LocalEngramRepository } from "../../adapters/local/index.js";
 import { join } from "node:path";
 import { existsSync } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
@@ -14,6 +17,71 @@ const server = new McpServer({
     name: "relic",
     version: "0.1.0",
 });
+// --- relic_engram_create ---
+server.tool("relic_engram_create", "Create a new Engram (AI persona). Use this after gathering enough context about the desired persona through conversation. Ask the user about personality, voice, principles, and identity before calling this tool.", {
+    id: z
+        .string()
+        .describe("Unique Engram ID (lowercase alphanumeric + hyphens, e.g. 'my-agent')"),
+    name: z.string().describe("Display name for the Engram"),
+    description: z
+        .string()
+        .optional()
+        .describe("Short description of the Engram"),
+    tags: z
+        .array(z.string())
+        .optional()
+        .describe("Tags for categorization"),
+    soul: z
+        .string()
+        .optional()
+        .describe("SOUL.md content — core principles, behavior rules, voice discipline, and boundaries. If omitted, a sensible default template is used."),
+    identity: z
+        .string()
+        .optional()
+        .describe("IDENTITY.md content — name, creature type, vibe, emoji, avatar, and background. If omitted, a blank template is used for the user to fill in."),
+    path: z
+        .string()
+        .optional()
+        .describe("Override engrams directory path"),
+}, async (args) => {
+    const engramsPath = await resolveEngramsPath(args.path);
+    const repo = new LocalEngramRepository(engramsPath);
+    const usecase = new CreateEngram(repo);
+    try {
+        const result = await usecase.execute({
+            id: args.id,
+            name: args.name,
+            description: args.description,
+            tags: args.tags,
+            soul: args.soul ?? DEFAULT_SOUL,
+            identity: args.identity ?? DEFAULT_IDENTITY,
+        });
+        const engramDir = join(engramsPath, result.engram.meta.id);
+        const lines = [
+            `Created Engram "${result.engram.meta.name}" (${result.engram.meta.id})`,
+            `Directory: ${engramDir}/`,
+            "",
+            "Files created:",
+            "  engram.json    — metadata (name, description, tags)",
+            "  manifest.json  — system metadata (id, timestamps)",
+            "  SOUL.md        — core principles and behavior",
+            "  IDENTITY.md    — persona identity",
+        ];
+        return {
+            content: [{ type: "text", text: lines.join("\n") }],
+        };
+    }
+    catch (err) {
+        if (err instanceof EngramAlreadyExistsError ||
+            err instanceof InvalidEngramIdError) {
+            return {
+                content: [{ type: "text", text: err.message }],
+                isError: true,
+            };
+        }
+        throw err;
+    }
+});
 // --- 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"),

package/dist/shared/config.d.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+declare const TEMPLATES_DIR: string;
 declare const RELIC_DIR: string;
 declare const CONFIG_PATH: string;
 export declare const RelicConfigSchema: z.ZodObject<{
@@ -65,4 +66,4 @@ export declare function resolveClawPath(cliOverride?: string): Promise<string |
  * 優先順位: config.memoryWindowSize > 2 (デフォルト)
  */
 export declare function resolveMemoryWindowSize(): Promise<number>;
-export { CONFIG_PATH, RELIC_DIR };
+export { CONFIG_PATH, RELIC_DIR, TEMPLATES_DIR };