@ectplsm/relic 0.1.1 → 0.1.3

package/dist/adapters/shells/trust-registrar.js

@@ -0,0 +1,141 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { existsSync } from "node:fs";
+export async function registerTrustedFolders(relicEngramsPath) {
+    const result = { registered: [], skipped: [] };
+    await Promise.all([
+        registerClaude(relicEngramsPath, result),
+        registerCodex(relicEngramsPath, result),
+        registerGemini(relicEngramsPath, result),
+    ]);
+    return result;
+}
+// ---------------------------------------------------------------------------
+// Claude Code — ~/.claude/settings.json
+// { "sandbox": { "filesystem": { "allowWrite": ["~/.relic/engrams"] } } }
+// ---------------------------------------------------------------------------
+async function registerClaude(engramsPath, result) {
+    const claudeDir = join(homedir(), ".claude");
+    const configPath = join(claudeDir, "settings.json");
+    if (!existsSync(claudeDir)) {
+        return;
+    }
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let settings = {};
+        if (existsSync(configPath)) {
+            const raw = await readFile(configPath, "utf-8");
+            settings = JSON.parse(raw);
+        }
+        // sandbox.filesystem.allowWrite を確保
+        settings.sandbox ??= {};
+        settings.sandbox.filesystem ??= {};
+        settings.sandbox.filesystem.allowWrite ??= [];
+        const allowWrite = settings.sandbox.filesystem.allowWrite;
+        // permissions.allow — ツール承認の自動化
+        settings.permissions ??= {};
+        settings.permissions.allow ??= [];
+        const allow = settings.permissions.allow;
+        const tildeForm = engramsPath.replace(homedir(), "~");
+        // sandbox: allowWrite
+        const sandboxNeeded = !allowWrite.includes(engramsPath) && !allowWrite.includes(tildeForm);
+        if (sandboxNeeded) {
+            allowWrite.push(tildeForm);
+        }
+        // permissions: Edit allow
+        const editRule = `Edit(${tildeForm}/**)`;
+        const permNeeded = !allow.includes(editRule);
+        if (permNeeded) {
+            allow.push(editRule);
+        }
+        if (!sandboxNeeded && !permNeeded) {
+            result.skipped.push("Claude Code");
+            return;
+        }
+        await writeFile(configPath, JSON.stringify(settings, null, 2), "utf-8");
+        result.registered.push("Claude Code");
+    }
+    catch {
+        // best effort
+    }
+}
+// ---------------------------------------------------------------------------
+// Codex CLI — ~/.codex/config.toml
+// [sandbox]
+// writable_roots = ["~/.relic/engrams"]
+// ---------------------------------------------------------------------------
+async function registerCodex(engramsPath, result) {
+    const codexDir = join(homedir(), ".codex");
+    const configPath = join(codexDir, "config.toml");
+    if (!existsSync(codexDir)) {
+        return;
+    }
+    try {
+        let content = "";
+        if (existsSync(configPath)) {
+            content = await readFile(configPath, "utf-8");
+        }
+        const tildeForm = engramsPath.replace(homedir(), "~");
+        // 既に writable_roots に含まれているかチェック
+        if (content.includes(engramsPath) || content.includes(tildeForm)) {
+            result.skipped.push("Codex CLI");
+            return;
+        }
+        // [sandbox] セクションが存在するか
+        const sandboxMatch = content.match(/^\[sandbox\]\s*$/m);
+        if (sandboxMatch) {
+            // [sandbox] セクション内の writable_roots を探す
+            const writableMatch = content.match(/^(writable_roots\s*=\s*\[)(.*?)(\])/m);
+            if (writableMatch) {
+                // 既存の writable_roots に追加
+                const existing = writableMatch[2].trim();
+                const newValue = existing
+                    ? `${existing}, "${tildeForm}"`
+                    : `"${tildeForm}"`;
+                content = content.replace(/^(writable_roots\s*=\s*\[)(.*?)(\])/m, `$1${newValue}$3`);
+            }
+            else {
+                // [sandbox] セクションに writable_roots を追加
+                content = content.replace(/^\[sandbox\]\s*$/m, `[sandbox]\nwritable_roots = ["${tildeForm}"]`);
+            }
+        }
+        else {
+            // [sandbox] セクションごと追加
+            content =
+                content.trimEnd() + `\n\n[sandbox]\nwritable_roots = ["${tildeForm}"]\n`;
+        }
+        await writeFile(configPath, content, "utf-8");
+        result.registered.push("Codex CLI");
+    }
+    catch {
+        // best effort
+    }
+}
+// ---------------------------------------------------------------------------
+// Gemini CLI — ~/.gemini/trustedFolders.json
+// { "/path/to/engrams": "TRUST_FOLDER" }
+// ---------------------------------------------------------------------------
+async function registerGemini(engramsPath, result) {
+    const configPath = join(homedir(), ".gemini", "trustedFolders.json");
+    if (!existsSync(join(homedir(), ".gemini"))) {
+        return;
+    }
+    try {
+        let folders = {};
+        if (existsSync(configPath)) {
+            const raw = await readFile(configPath, "utf-8");
+            folders = JSON.parse(raw);
+        }
+        if (folders[engramsPath]) {
+            result.skipped.push("Gemini CLI");
+            return;
+        }
+        folders[engramsPath] = "TRUST_FOLDER";
+        await writeFile(configPath, JSON.stringify(folders, null, 2), "utf-8");
+        result.registered.push("Gemini CLI");
+    }
+    catch {
+        // best effort
+    }
+}

package/dist/core/ports/shell-launcher.d.ts

@@ -2,15 +2,30 @@
  * 注入モード — ShellがEngramをどの経路で受け取るか
  *
  * - system-prompt: システムプロンプトとして直接上書き（最も強力）
+ * - developer-message: developerロールのメッセージとして注入（system-promptに準じる強度）
  * - instruction-file: 設定ファイルに書き出して補助指示として注入
  * - user-message: 初回ユーザーメッセージとして送り込む
  */
-export type InjectionMode = "system-prompt" | "instruction-file" | "user-message";
+export type InjectionMode = "system-prompt" | "developer-message" | "instruction-file" | "user-message";
+/**
+ * Shell起動オプション
+ */
+export interface ShellLaunchOptions {
+    /** Shell に追加で渡す引数 */
+    extraArgs?: string[];
+    /** Shell の作業ディレクトリ */
+    cwd?: string;
+    /** 注入するEngram ID（Shell固有のセットアップに使用） */
+    engramId?: string;
+}
 /**
  * ShellLauncher — AI CLIにEngramを注入して起動する抽象ポート
  *
  * 各Shell(LLM CLI)ごとにシステムプロンプトの渡し方が異なるため、
  * 具象実装はadapters/shells/に配置される。
+ *
+ * archiveへの書き込みはバックグラウンドhookが自動で行う。
+ * ShellLauncherは注入に特化する。
  */
 export interface ShellLauncher {
     /** Shell種別の表示名 */
@@ -23,5 +38,5 @@ export interface ShellLauncher {
      * EngramプロンプトをShellに注入して起動する。
      * プロセスはフォアグラウンドで実行され、ユーザーが終了するまでブロックする。
      */
-    launch(prompt: string, extraArgs?: string[], cwd?: string): Promise<void>;
+    launch(prompt: string, options?: ShellLaunchOptions): Promise<void>;
 }

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

@@ -0,0 +1,21 @@
+export interface ArchiveCursorUpdateResult {
+    /** 更新前のcursor位置 */
+    previousCursor: number;
+    /** 更新後のcursor位置 */
+    newCursor: number;
+}
+/**
+ * ArchiveCursorUpdate — archive.cursor を指定件数分だけ進める
+ *
+ * relic_memory_write 時に呼ばれ、蒸留済みエントリ数だけcursorを前進させる。
+ * 実際に蒸留した件数（= relic_archive_pending で返した件数）を受け取る。
+ */
+export declare class ArchiveCursorUpdate {
+    private readonly engramsPath;
+    constructor(engramsPath: string);
+    execute(engramId: string, count: number): Promise<ArchiveCursorUpdateResult>;
+    private readCursor;
+}
+export declare class ArchiveCursorUpdateEngramNotFoundError extends Error {
+    constructor(id: string);
+}

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

@@ -0,0 +1,44 @@
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+/**
+ * ArchiveCursorUpdate — archive.cursor を指定件数分だけ進める
+ *
+ * relic_memory_write 時に呼ばれ、蒸留済みエントリ数だけcursorを前進させる。
+ * 実際に蒸留した件数（= relic_archive_pending で返した件数）を受け取る。
+ */
+export class ArchiveCursorUpdate {
+    engramsPath;
+    constructor(engramsPath) {
+        this.engramsPath = engramsPath;
+    }
+    async execute(engramId, count) {
+        const engramDir = join(this.engramsPath, engramId);
+        if (!existsSync(engramDir)) {
+            throw new ArchiveCursorUpdateEngramNotFoundError(engramId);
+        }
+        const cursorPath = join(engramDir, "archive.cursor");
+        const previousCursor = await this.readCursor(cursorPath);
+        const newCursor = previousCursor + count;
+        await writeFile(cursorPath, String(newCursor), "utf-8");
+        return { previousCursor, newCursor };
+    }
+    async readCursor(cursorPath) {
+        if (!existsSync(cursorPath))
+            return 0;
+        try {
+            const raw = await readFile(cursorPath, "utf-8");
+            const value = parseInt(raw.trim(), 10);
+            return Number.isNaN(value) ? 0 : value;
+        }
+        catch {
+            return 0;
+        }
+    }
+}
+export class ArchiveCursorUpdateEngramNotFoundError extends Error {
+    constructor(id) {
+        super(`Engram "${id}" archive not found`);
+        this.name = "ArchiveCursorUpdateEngramNotFoundError";
+    }
+}

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

@@ -0,0 +1,25 @@
+export interface ArchivePendingResult {
+    /** 未蒸留エントリ（cursor以降） */
+    entries: string[];
+    /** 現在のcursor位置 */
+    cursor: number;
+    /** archive内の総エントリ数 */
+    total: number;
+    /** 今回返さなかった残りの未蒸留エントリ数 */
+    remaining: number;
+}
+/**
+ * ArchivePending — archive.md の未蒸留エントリを取得する
+ *
+ * archive.cursor に記録された位置以降のエントリを返す。
+ * 読み取り専用 — cursorの更新は ArchiveCursorUpdate が担う。
+ */
+export declare class ArchivePending {
+    private readonly engramsPath;
+    constructor(engramsPath: string);
+    execute(engramId: string, limit?: number): Promise<ArchivePendingResult>;
+    private readCursor;
+}
+export declare class ArchivePendingEngramNotFoundError extends Error {
+    constructor(id: string);
+}

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

@@ -0,0 +1,61 @@
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+const ENTRY_SEPARATOR = /\n---\n/;
+const DEFAULT_LIMIT = 30;
+/**
+ * ArchivePending — archive.md の未蒸留エントリを取得する
+ *
+ * archive.cursor に記録された位置以降のエントリを返す。
+ * 読み取り専用 — cursorの更新は ArchiveCursorUpdate が担う。
+ */
+export class ArchivePending {
+    engramsPath;
+    constructor(engramsPath) {
+        this.engramsPath = engramsPath;
+    }
+    async execute(engramId, limit) {
+        const engramDir = join(this.engramsPath, engramId);
+        const archivePath = join(engramDir, "archive.md");
+        if (!existsSync(archivePath)) {
+            throw new ArchivePendingEngramNotFoundError(engramId);
+        }
+        const raw = await readFile(archivePath, "utf-8");
+        if (!raw.trim()) {
+            return { entries: [], cursor: 0, total: 0, remaining: 0 };
+        }
+        const allEntries = raw
+            .split(ENTRY_SEPARATOR)
+            .map((e) => e.trim())
+            .filter((e) => e.length > 0);
+        const cursor = await this.readCursor(engramDir);
+        const pendingEntries = allEntries.slice(cursor);
+        const effectiveLimit = limit ?? DEFAULT_LIMIT;
+        const returned = pendingEntries.slice(0, effectiveLimit);
+        return {
+            entries: returned,
+            cursor,
+            total: allEntries.length,
+            remaining: pendingEntries.length - returned.length,
+        };
+    }
+    async readCursor(engramDir) {
+        const cursorPath = join(engramDir, "archive.cursor");
+        if (!existsSync(cursorPath))
+            return 0;
+        try {
+            const raw = await readFile(cursorPath, "utf-8");
+            const value = parseInt(raw.trim(), 10);
+            return Number.isNaN(value) ? 0 : value;
+        }
+        catch {
+            return 0;
+        }
+    }
+}
+export class ArchivePendingEngramNotFoundError extends Error {
+    constructor(id) {
+        super(`Engram "${id}" archive not found`);
+        this.name = "ArchivePendingEngramNotFoundError";
+    }
+}

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

@@ -0,0 +1,20 @@
+export interface ArchiveSearchResult {
+    /** マッチしたエントリの内容 */
+    entry: string;
+    /** エントリのインデックス（新しい順: 0が最新） */
+    index: number;
+}
+/**
+ * ArchiveSearch — archive.md をキーワード検索する
+ *
+ * archive.md は全セッションログ + [memory] エントリを含む生データ。
+ * memory/*.md（蒸留済み）より情報量が多いため、検索先として優れている。
+ */
+export declare class ArchiveSearch {
+    private readonly engramsPath;
+    constructor(engramsPath: string);
+    search(engramId: string, query: string, limit?: number): Promise<ArchiveSearchResult[]>;
+}
+export declare class ArchiveSearchEngramNotFoundError extends Error {
+    constructor(id: string);
+}

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

@@ -0,0 +1,46 @@
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+const ENTRY_SEPARATOR = /\n---\n/;
+/**
+ * ArchiveSearch — archive.md をキーワード検索する
+ *
+ * archive.md は全セッションログ + [memory] エントリを含む生データ。
+ * memory/*.md（蒸留済み）より情報量が多いため、検索先として優れている。
+ */
+export class ArchiveSearch {
+    engramsPath;
+    constructor(engramsPath) {
+        this.engramsPath = engramsPath;
+    }
+    async search(engramId, query, limit = 5) {
+        const archivePath = join(this.engramsPath, engramId, "archive.md");
+        if (!existsSync(archivePath)) {
+            throw new ArchiveSearchEngramNotFoundError(engramId);
+        }
+        const raw = await readFile(archivePath, "utf-8");
+        if (!raw.trim())
+            return [];
+        const entries = raw
+            .split(ENTRY_SEPARATOR)
+            .map((e) => e.trim())
+            .filter((e) => e.length > 0)
+            .reverse(); // 新しい順
+        const queryLower = query.toLowerCase();
+        const results = [];
+        for (let i = 0; i < entries.length; i++) {
+            if (entries[i].toLowerCase().includes(queryLower)) {
+                results.push({ entry: entries[i], index: i });
+            }
+            if (results.length >= limit)
+                break;
+        }
+        return results;
+    }
+}
+export class ArchiveSearchEngramNotFoundError extends Error {
+    constructor(id) {
+        super(`Engram "${id}" archive not found`);
+        this.name = "ArchiveSearchEngramNotFoundError";
+    }
+}

package/dist/core/usecases/inbox-search.d.ts

@@ -0,0 +1,20 @@
+export interface InboxSearchResult {
+    /** マッチしたエントリの内容 */
+    entry: string;
+    /** エントリのインデックス（新しい順: 0が最新） */
+    index: number;
+}
+/**
+ * InboxSearch — inbox.md をキーワード検索する
+ *
+ * inbox.md は全セッションログ + [memory] エントリを含む生データ。
+ * memory/*.md（蒸留済み）より情報量が多いため、検索先として優れている。
+ */
+export declare class InboxSearch {
+    private readonly engramsPath;
+    constructor(engramsPath: string);
+    search(engramId: string, query: string, limit?: number): Promise<InboxSearchResult[]>;
+}
+export declare class InboxSearchEngramNotFoundError extends Error {
+    constructor(id: string);
+}

package/dist/core/usecases/inbox-search.js

@@ -0,0 +1,46 @@
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+const ENTRY_SEPARATOR = /\n---\n/;
+/**
+ * InboxSearch — inbox.md をキーワード検索する
+ *
+ * inbox.md は全セッションログ + [memory] エントリを含む生データ。
+ * memory/*.md（蒸留済み）より情報量が多いため、検索先として優れている。
+ */
+export class InboxSearch {
+    engramsPath;
+    constructor(engramsPath) {
+        this.engramsPath = engramsPath;
+    }
+    async search(engramId, query, limit = 5) {
+        const inboxPath = join(this.engramsPath, engramId, "inbox.md");
+        if (!existsSync(inboxPath)) {
+            throw new InboxSearchEngramNotFoundError(engramId);
+        }
+        const raw = await readFile(inboxPath, "utf-8");
+        if (!raw.trim())
+            return [];
+        const entries = raw
+            .split(ENTRY_SEPARATOR)
+            .map((e) => e.trim())
+            .filter((e) => e.length > 0)
+            .reverse(); // 新しい順
+        const queryLower = query.toLowerCase();
+        const results = [];
+        for (let i = 0; i < entries.length; i++) {
+            if (entries[i].toLowerCase().includes(queryLower)) {
+                results.push({ entry: entries[i], index: i });
+            }
+            if (results.length >= limit)
+                break;
+        }
+        return results;
+    }
+}
+export class InboxSearchEngramNotFoundError extends Error {
+    constructor(id) {
+        super(`Engram "${id}" inbox not found`);
+        this.name = "InboxSearchEngramNotFoundError";
+    }
+}

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

@@ -0,0 +1,27 @@
+export interface InboxWriteResult {
+    engramId: string;
+    /** inbox.md に追記されたエントリ数 */
+    totalEntries: number;
+    /** memory/*.md に永続化されたメモリ数 */
+    memoriesSaved: number;
+    /** ログとして記録されたエントリ数 */
+    logsRecorded: number;
+}
+/**
+ * InboxWrite — MCP経由で inbox.md にエントリを追記する
+ *
+ * CLI の MemoryInbox (fs.watch) と同じフォーマットで inbox.md に書き込む。
+ * `[memory]` タグ付きエントリは即座に memory/*.md にも永続化する。
+ *
+ * これにより CLI Shell と MCP Desktop で同一の inbox.md フォーマットを共有し、
+ * セッションログ + メモリ永続化の二重の役割を果たす。
+ */
+export declare class InboxWrite {
+    private readonly engramsPath;
+    constructor(engramsPath: string);
+    execute(engramId: string, content: string): Promise<InboxWriteResult>;
+    private appendToInbox;
+}
+export declare class InboxWriteEngramNotFoundError extends Error {
+    constructor(id: string);
+}

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

@@ -0,0 +1,72 @@
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { MemoryWrite } from "./memory-write.js";
+const ENTRY_SEPARATOR = /\n---\n/;
+const MEMORY_TAG = /^\[memory\]\s*/i;
+/**
+ * InboxWrite — MCP経由で inbox.md にエントリを追記する
+ *
+ * CLI の MemoryInbox (fs.watch) と同じフォーマットで inbox.md に書き込む。
+ * `[memory]` タグ付きエントリは即座に memory/*.md にも永続化する。
+ *
+ * これにより CLI Shell と MCP Desktop で同一の inbox.md フォーマットを共有し、
+ * セッションログ + メモリ永続化の二重の役割を果たす。
+ */
+export class InboxWrite {
+    engramsPath;
+    constructor(engramsPath) {
+        this.engramsPath = engramsPath;
+    }
+    async execute(engramId, content) {
+        const engramDir = join(this.engramsPath, engramId);
+        if (!existsSync(engramDir)) {
+            throw new InboxWriteEngramNotFoundError(engramId);
+        }
+        // inbox.md に追記
+        const inboxPath = join(engramDir, "inbox.md");
+        await this.appendToInbox(inboxPath, content);
+        // エントリをパースして [memory] タグ付きを永続化
+        const entries = content
+            .split(ENTRY_SEPARATOR)
+            .map((e) => e.trim())
+            .filter((e) => e.length > 0);
+        const writer = new MemoryWrite(this.engramsPath);
+        let memoriesSaved = 0;
+        let logsRecorded = 0;
+        for (const entry of entries) {
+            if (MEMORY_TAG.test(entry)) {
+                const memContent = entry.replace(MEMORY_TAG, "").trim();
+                await writer.execute(engramId, memContent);
+                memoriesSaved++;
+            }
+            else {
+                logsRecorded++;
+            }
+        }
+        return {
+            engramId,
+            totalEntries: entries.length,
+            memoriesSaved,
+            logsRecorded,
+        };
+    }
+    async appendToInbox(inboxPath, content) {
+        await mkdir(join(inboxPath, ".."), { recursive: true });
+        let existing = "";
+        if (existsSync(inboxPath)) {
+            existing = await readFile(inboxPath, "utf-8");
+        }
+        // 既存内容があれば --- で区切って追記
+        const separator = existing.length > 0 && !existing.endsWith("\n---\n")
+            ? "\n---\n"
+            : "";
+        await writeFile(inboxPath, existing + separator + content + "\n", "utf-8");
+    }
+}
+export class InboxWriteEngramNotFoundError extends Error {
+    constructor(id) {
+        super(`Engram "${id}" not found`);
+        this.name = "InboxWriteEngramNotFoundError";
+    }
+}

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

@@ -3,6 +3,7 @@ export { ListEngrams } from "./list-engrams.js";
 export { Init, type InitResult } from "./init.js";
 export { Inject, InjectEngramNotFoundError, InjectAgentNotFoundError, type InjectResult, } from "./inject.js";
 export { Extract, WorkspaceNotFoundError, WorkspaceEmptyError, EngramAlreadyExistsError, ExtractNameRequiredError, type ExtractResult, } from "./extract.js";
-export { MemorySearch, MemoryEngramNotFoundError, type MemorySearchResult, } from "./memory-search.js";
 export { MemoryWrite, MemoryWriteEngramNotFoundError, type MemoryWriteResult, } from "./memory-write.js";
 export { Sync, SyncAgentsDirNotFoundError, type SyncTarget, type SyncInitialResult, } from "./sync.js";
+export { ArchivePending, ArchivePendingEngramNotFoundError, type ArchivePendingResult, } from "./archive-pending.js";
+export { ArchiveCursorUpdate, ArchiveCursorUpdateEngramNotFoundError, type ArchiveCursorUpdateResult, } from "./archive-cursor-update.js";

package/dist/core/usecases/index.js

@@ -3,6 +3,7 @@ export { ListEngrams } from "./list-engrams.js";
 export { Init } from "./init.js";
 export { Inject, InjectEngramNotFoundError, InjectAgentNotFoundError, } from "./inject.js";
 export { Extract, WorkspaceNotFoundError, WorkspaceEmptyError, EngramAlreadyExistsError, ExtractNameRequiredError, } from "./extract.js";
-export { MemorySearch, MemoryEngramNotFoundError, } from "./memory-search.js";
 export { MemoryWrite, MemoryWriteEngramNotFoundError, } from "./memory-write.js";
 export { Sync, SyncAgentsDirNotFoundError, } from "./sync.js";
+export { ArchivePending, ArchivePendingEngramNotFoundError, } from "./archive-pending.js";
+export { ArchiveCursorUpdate, ArchiveCursorUpdateEngramNotFoundError, } from "./archive-cursor-update.js";

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

@@ -12,11 +12,16 @@ export interface SummonResult {
  *
  * これがRELICの中核オペレーション。
  * Engramの取得 → Markdown結合 → 注入可能なプロンプト生成 を行う。
+ *
+ * archiveへの書き込みはバックグラウンドhookが自動で行う。
+ * CLIはEngramの注入に特化する。
  */
 export declare class Summon {
     private readonly repository;
     constructor(repository: EngramRepository);
-    execute(engramId: string): Promise<SummonResult>;
+    execute(engramId: string, options?: {
+        memoryWindowSize?: number;
+    }): Promise<SummonResult>;
 }
 export declare class EngramNotFoundError extends Error {
     constructor(id: string);

package/dist/core/usecases/summon.js

@@ -4,18 +4,24 @@ import { composeEngram } from "../../shared/engram-composer.js";
  *
  * これがRELICの中核オペレーション。
  * Engramの取得 → Markdown結合 → 注入可能なプロンプト生成 を行う。
+ *
+ * archiveへの書き込みはバックグラウンドhookが自動で行う。
+ * CLIはEngramの注入に特化する。
  */
 export class Summon {
     repository;
     constructor(repository) {
         this.repository = repository;
     }
-    async execute(engramId) {
+    async execute(engramId, options) {
         const engram = await this.repository.get(engramId);
         if (!engram) {
             throw new EngramNotFoundError(engramId);
         }
-        const prompt = composeEngram(engram.files);
+        const prompt = composeEngram(engram.files, {
+            meta: engram.meta,
+            memoryWindowSize: options?.memoryWindowSize,
+        });
         return {
             engramId: engram.meta.id,
             engramName: engram.meta.name,

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

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