@ectplsm/relic 0.1.4 → 0.2.0

package/dist/core/usecases/index.js

@@ -1,9 +1,9 @@
 export { Summon, EngramNotFoundError } from "./summon.js";
 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 { Inject, InjectEngramNotFoundError, InjectClawDirNotFoundError, InjectWorkspaceNotFoundError, } from "./inject.js";
+export { Extract, WorkspaceNotFoundError, WorkspaceEmptyError, AlreadyExtractedError, } from "./extract.js";
 export { MemoryWrite, MemoryWriteEngramNotFoundError, } from "./memory-write.js";
-export { Sync, SyncAgentsDirNotFoundError, } from "./sync.js";
+export { Sync, SyncOpenclawDirNotFoundError, } from "./sync.js";
 export { ArchivePending, ArchivePendingEngramNotFoundError, } from "./archive-pending.js";
 export { ArchiveCursorUpdate, ArchiveCursorUpdateEngramNotFoundError, } from "./archive-cursor-update.js";

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

@@ -8,7 +8,8 @@ export interface InjectResult {
 /**
  * Inject — EngramのファイルをOpenClawワークスペースに注入する
  *
- * agent名 = Engram ID の規約に基づき、agents/<engramId>/agent/ に書き込む。
+ * OpenClawではエージェントごとに workspace-<name>/ を使い、
+ * デフォルト(main)エージェントのみ workspace/ を使う。
  * memoryEntries はOpenClaw側の管理に委ねるため注入しない。
  */
 export declare class Inject {
@@ -17,12 +18,16 @@ export declare class Inject {
     execute(engramId: string, options?: {
         to?: string;
         openclawDir?: string;
+        mergeIdentity?: boolean;
     }): Promise<InjectResult>;
     private writeFiles;
 }
 export declare class InjectEngramNotFoundError extends Error {
     constructor(id: string);
 }
-export declare class InjectAgentNotFoundError extends Error {
-    constructor(engramId: string, path: string);
+export declare class InjectClawDirNotFoundError extends Error {
+    constructor(path: string);
+}
+export declare class InjectWorkspaceNotFoundError extends Error {
+    constructor(engramId: string);
 }

package/dist/core/usecases/inject.js

@@ -1,11 +1,12 @@
 import { join } from "node:path";
 import { existsSync } from "node:fs";
 import { writeFile } from "node:fs/promises";
-import { FILE_MAP, resolveAgentPath } from "../../shared/openclaw.js";
+import { INJECT_FILE_MAP, resolveWorkspacePath } from "../../shared/openclaw.js";
 /**
  * Inject — EngramのファイルをOpenClawワークスペースに注入する
  *
- * agent名 = Engram ID の規約に基づき、agents/<engramId>/agent/ に書き込む。
+ * OpenClawではエージェントごとに workspace-<name>/ を使い、
+ * デフォルト(main)エージェントのみ workspace/ を使う。
  * memoryEntries はOpenClaw側の管理に委ねるため注入しない。
  */
 export class Inject {
@@ -18,12 +19,16 @@ export class Inject {
         if (!engram) {
             throw new InjectEngramNotFoundError(engramId);
         }
+        // ベースディレクトリ（--dir）の存在チェック
+        if (options?.openclawDir && !existsSync(options.openclawDir)) {
+            throw new InjectClawDirNotFoundError(options.openclawDir);
+        }
         const agentName = options?.to ?? engramId;
-        const targetPath = resolveAgentPath(agentName, options?.openclawDir);
+        const targetPath = resolveWorkspacePath(agentName, options?.openclawDir);
         if (!existsSync(targetPath)) {
-            throw new InjectAgentNotFoundError(agentName, targetPath);
+            throw new InjectWorkspaceNotFoundError(agentName);
         }
-        const filesWritten = await this.writeFiles(targetPath, engram.files);
+        const filesWritten = await this.writeFiles(targetPath, engram.files, options?.mergeIdentity ?? false);
         return {
             engramId: engram.meta.id,
             engramName: engram.meta.name,
@@ -31,10 +36,18 @@ export class Inject {
             filesWritten,
         };
     }
-    async writeFiles(targetPath, files) {
+    async writeFiles(targetPath, files, mergeIdentity) {
         const written = [];
-        for (const [key, filename] of Object.entries(FILE_MAP)) {
-            const content = files[key];
+        for (const [key, filename] of Object.entries(INJECT_FILE_MAP)) {
+            // --merge-identity: skip IDENTITY.md (merged into SOUL.md below)
+            if (mergeIdentity && key === "identity") {
+                continue;
+            }
+            let content = files[key];
+            // --merge-identity: append IDENTITY.md content to SOUL.md
+            if (mergeIdentity && key === "soul" && files.identity) {
+                content = content + "\n" + files.identity;
+            }
             if (content !== undefined) {
                 await writeFile(join(targetPath, filename), content, "utf-8");
                 written.push(filename);
@@ -49,9 +62,15 @@ export class InjectEngramNotFoundError extends Error {
         this.name = "InjectEngramNotFoundError";
     }
 }
-export class InjectAgentNotFoundError extends Error {
-    constructor(engramId, path) {
-        super(`OpenClaw agent "${engramId}" not found at ${path}. The agent must exist before injecting.`);
-        this.name = "InjectAgentNotFoundError";
+export class InjectClawDirNotFoundError extends Error {
+    constructor(path) {
+        super(`Claw directory not found at ${path}`);
+        this.name = "InjectClawDirNotFoundError";
+    }
+}
+export class InjectWorkspaceNotFoundError extends Error {
+    constructor(engramId) {
+        super(`OpenClaw agent "${engramId}" has not been created yet. Run "openclaw agents add ${engramId}" first, then try again.`);
+        this.name = "InjectWorkspaceNotFoundError";
     }
 }

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

@@ -1,40 +1,64 @@
 import type { EngramRepository } from "../ports/engram-repository.js";
 export interface SyncTarget {
     engramId: string;
-    agentPath: string;
-    hasEngram: boolean;
+    workspacePath: string;
+}
+export interface SyncResult {
+    engramId: string;
+    memoryFilesMerged: number;
+    memoryIndexMerged: boolean;
+    userMerged: boolean;
 }
 export interface SyncInitialResult {
-    injected: string[];
-    extracted: string[];
-    targets: SyncTarget[];
+    synced: SyncResult[];
+    skipped: string[];
 }
 /**
- * Sync — OpenClawのagentsディレクトリをスキャンし、
- * 一致するEngramをinject / memoryをextractする。
+ * Sync — Relic Engram と OpenClaw workspace 間で memory を双方向マージする。
  *
- * 初回スキャン後は、呼び出し側がファイル監視を行い、
- * 変更検知時に syncMemory() を呼ぶ。
+ * 対象: 同名の engram/agent が両方に存在するペアのみ。
+ * マージ対象: memory/*.md と MEMORY.md
+ * マージ結果は両方に書き戻される。
  */
 export declare class Sync {
     private readonly repository;
-    private readonly inject;
-    private readonly extract;
-    constructor(repository: EngramRepository);
+    private readonly engramsPath;
+    constructor(repository: EngramRepository, engramsPath: string);
+    execute(openclawDir?: string): Promise<SyncInitialResult>;
+    /**
+     * 1ペア分の memory マージ（inject 後の自動 sync 等でも使用）
+     */
+    syncPair(target: SyncTarget): Promise<SyncResult>;
+    /**
+     * memory/*.md を双方向マージ
+     */
+    private mergeMemoryEntries;
+    /**
+     * MEMORY.md を双方向マージ
+     */
+    private mergeMemoryIndex;
+    /**
+     * 単一ファイルの双方向マージ（MEMORY.md, USER.md 等）
+     */
+    private mergeSingleFile;
+    /**
+     * 2つのテキスト内容をマージする。
+     * 重複行を除外しつつ、両方の内容を結合する。
+     */
+    private mergeContents;
     /**
-     * OpenClawのagentsディレクトリをスキャンし、
-     * Engramが存在するagentにはinject、全agentからmemoryをextractする。
+     * memory/ ディレクトリから日付 → 内容のマップを読む
      */
-    initialSync(openclawDir?: string): Promise<SyncInitialResult>;
+    private readMemoryDir;
     /**
-     * 特定agentのmemoryを同期（ファイル変更検知時に呼ばれる）
+     * 同名の engram/agent が両方に存在するペアを返す
      */
-    syncMemory(engramId: string, openclawDir?: string): Promise<void>;
+    private scanMatchingPairs;
     /**
-     * agentsディレクトリをスキャンしてターゲット一覧を返す
+     * 全 workspace のエージェント名一覧
      */
-    private scanAgents;
+    private scanAllWorkspaces;
 }
-export declare class SyncAgentsDirNotFoundError extends Error {
+export declare class SyncOpenclawDirNotFoundError extends Error {
     constructor(path: string);
 }

package/dist/core/usecases/sync.js

@@ -1,94 +1,220 @@
-import { join } from "node:path";
 import { existsSync } from "node:fs";
-import { readdir } from "node:fs/promises";
+import { readdir, readFile, writeFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
 import { homedir } from "node:os";
-import { Inject } from "./inject.js";
-import { Extract } from "./extract.js";
+import { extractAgentName, MEMORY_DIR } from "../../shared/openclaw.js";
 const DEFAULT_OPENCLAW_DIR = join(homedir(), ".openclaw");
+const MEMORY_INDEX = "MEMORY.md";
 /**
- * Sync — OpenClawのagentsディレクトリをスキャンし、
- * 一致するEngramをinject / memoryをextractする。
+ * Sync — Relic Engram と OpenClaw workspace 間で memory を双方向マージする。
  *
- * 初回スキャン後は、呼び出し側がファイル監視を行い、
- * 変更検知時に syncMemory() を呼ぶ。
+ * 対象: 同名の engram/agent が両方に存在するペアのみ。
+ * マージ対象: memory/*.md と MEMORY.md
+ * マージ結果は両方に書き戻される。
  */
 export class Sync {
     repository;
-    inject;
-    extract;
-    constructor(repository) {
+    engramsPath;
+    constructor(repository, engramsPath) {
         this.repository = repository;
-        this.inject = new Inject(repository);
-        this.extract = new Extract(repository);
+        this.engramsPath = engramsPath;
     }
-    /**
-     * OpenClawのagentsディレクトリをスキャンし、
-     * Engramが存在するagentにはinject、全agentからmemoryをextractする。
-     */
-    async initialSync(openclawDir) {
+    async execute(openclawDir) {
         const baseDir = openclawDir ?? DEFAULT_OPENCLAW_DIR;
-        const agentsDir = join(baseDir, "agents");
-        if (!existsSync(agentsDir)) {
-            throw new SyncAgentsDirNotFoundError(agentsDir);
+        if (!existsSync(baseDir)) {
+            throw new SyncOpenclawDirNotFoundError(baseDir);
         }
-        const targets = await this.scanAgents(agentsDir);
-        const injected = [];
-        const extracted = [];
+        const targets = await this.scanMatchingPairs(baseDir);
+        const synced = [];
+        const skipped = [];
         for (const target of targets) {
-            // Engramがあるagentにはpersonaを注入
-            if (target.hasEngram) {
-                try {
-                    await this.inject.execute(target.engramId, { openclawDir });
-                    injected.push(target.engramId);
-                }
-                catch {
-                    // inject失敗は警告として続行
-                }
-            }
-            // 全agentからmemoryを抽出
             try {
-                await this.extract.execute(target.engramId, {
-                    openclawDir,
-                });
-                extracted.push(target.engramId);
+                const result = await this.syncPair(target);
+                synced.push(result);
             }
             catch {
-                // extract失敗（新規Engramでname未指定等）はスキップ
+                skipped.push(target.engramId);
+            }
+        }
+        // workspace に対応する engram ��ないものを skipped に追加
+        const allWorkspaces = await this.scanAllWorkspaces(baseDir);
+        for (const ws of allWorkspaces) {
+            const matched = targets.some((t) => t.engramId === ws);
+            if (!matched) {
+                skipped.push(ws);
+            }
+        }
+        return { synced, skipped };
+    }
+    /**
+     * 1ペア分の memory マージ（inject 後の自動 sync 等でも使用）
+     */
+    async syncPair(target) {
+        const relicDir = join(this.engramsPath, target.engramId);
+        const openclawDir = target.workspacePath;
+        // memory/*.md のマージ
+        const memoryFilesMerged = await this.mergeMemoryEntries(relicDir, openclawDir);
+        // MEMORY.md のマージ
+        const memoryIndexMerged = await this.mergeMemoryIndex(relicDir, openclawDir);
+        // USER.md のマージ
+        const userMerged = await this.mergeSingleFile(relicDir, openclawDir, "USER.md");
+        return {
+            engramId: target.engramId,
+            memoryFilesMerged,
+            memoryIndexMerged,
+            userMerged,
+        };
+    }
+    /**
+     * memory/*.md を双方向マージ
+     */
+    async mergeMemoryEntries(relicDir, openclawDir) {
+        const relicMemDir = join(relicDir, MEMORY_DIR);
+        const openclawMemDir = join(openclawDir, MEMORY_DIR);
+        const relicEntries = await this.readMemoryDir(relicMemDir);
+        const openclawEntries = await this.readMemoryDir(openclawMemDir);
+        // 全日付の union
+        const allDates = new Set([
+            ...Object.keys(relicEntries),
+            ...Object.keys(openclawEntries),
+        ]);
+        let mergedCount = 0;
+        for (const date of allDates) {
+            const relicContent = relicEntries[date];
+            const openclawContent = openclawEntries[date];
+            if (relicContent && !openclawContent) {
+                // RELIC にだけある → OpenClaw にコピー
+                await mkdir(openclawMemDir, { recursive: true });
+                await writeFile(join(openclawMemDir, `${date}.md`), relicContent, "utf-8");
+                mergedCount++;
             }
+            else if (!relicContent && openclawContent) {
+                // OpenClaw にだけある → RELIC にコピー
+                await mkdir(relicMemDir, { recursive: true });
+                await writeFile(join(relicMemDir, `${date}.md`), openclawContent, "utf-8");
+                mergedCount++;
+            }
+            else if (relicContent && openclawContent && relicContent !== openclawContent) {
+                // 両方にあるが内容が違う → マージして両方に書き込み
+                const merged = this.mergeContents(relicContent, openclawContent);
+                await writeFile(join(relicMemDir, `${date}.md`), merged, "utf-8");
+                await writeFile(join(openclawMemDir, `${date}.md`), merged, "utf-8");
+                mergedCount++;
+            }
+            // 内容が同じ → 何もしない
         }
-        return { injected, extracted, targets };
+        return mergedCount;
     }
     /**
-     * 特定agentのmemoryを同期（ファイル変更検知時に呼ばれる）
+     * MEMORY.md を双方向マージ
      */
-    async syncMemory(engramId, openclawDir) {
-        await this.extract.execute(engramId, { openclawDir });
+    async mergeMemoryIndex(relicDir, openclawDir) {
+        return this.mergeSingleFile(relicDir, openclawDir, MEMORY_INDEX);
     }
     /**
-     * agentsディレクトリをスキャンしてターゲット一覧を返す
+     * 単一ファイルの双方向マージ（MEMORY.md, USER.md 等）
      */
-    async scanAgents(agentsDir) {
-        const entries = await readdir(agentsDir, { withFileTypes: true });
+    async mergeSingleFile(relicDir, openclawDir, filename) {
+        const relicPath = join(relicDir, filename);
+        const openclawPath = join(openclawDir, filename);
+        const relicContent = existsSync(relicPath)
+            ? await readFile(relicPath, "utf-8")
+            : null;
+        const openclawContent = existsSync(openclawPath)
+            ? await readFile(openclawPath, "utf-8")
+            : null;
+        if (relicContent && !openclawContent) {
+            await writeFile(openclawPath, relicContent, "utf-8");
+            return true;
+        }
+        else if (!relicContent && openclawContent) {
+            await writeFile(relicPath, openclawContent, "utf-8");
+            return true;
+        }
+        else if (relicContent && openclawContent && relicContent !== openclawContent) {
+            const merged = this.mergeContents(relicContent, openclawContent);
+            await writeFile(relicPath, merged, "utf-8");
+            await writeFile(openclawPath, merged, "utf-8");
+            return true;
+        }
+        return false;
+    }
+    /**
+     * 2つのテキスト内容をマージする。
+     * 重複行を除外しつつ、両方の内容を結合する。
+     */
+    mergeContents(a, b) {
+        const aLines = a.trimEnd();
+        const bLines = b.trimEnd();
+        // 完全一致チェック（ここには来ないはずだが安全策）
+        if (aLines === bLines)
+            return a;
+        // b の中で a に含まれない部分を抽出して追記
+        const aSet = new Set(aLines.split("\n"));
+        const uniqueB = bLines
+            .split("\n")
+            .filter((line) => !aSet.has(line));
+        if (uniqueB.length === 0)
+            return a;
+        return aLines + "\n\n" + uniqueB.join("\n") + "\n";
+    }
+    /**
+     * memory/ ディレクトリから日付 → 内容のマップを読む
+     */
+    async readMemoryDir(memDir) {
+        const entries = {};
+        if (!existsSync(memDir))
+            return entries;
+        const files = await readdir(memDir);
+        for (const file of files) {
+            if (!file.endsWith(".md"))
+                continue;
+            const date = file.replace(/\.md$/, "");
+            entries[date] = await readFile(join(memDir, file), "utf-8");
+        }
+        return entries;
+    }
+    /**
+     * 同名の engram/agent が両方に存在するペアを返す
+     */
+    async scanMatchingPairs(baseDir) {
+        const entries = await readdir(baseDir, { withFileTypes: true });
         const targets = [];
         for (const entry of entries) {
             if (!entry.isDirectory())
                 continue;
-            const agentPath = join(agentsDir, entry.name, "agent");
-            if (!existsSync(agentPath))
+            const agentName = extractAgentName(entry.name);
+            if (!agentName)
+                continue;
+            const engram = await this.repository.get(agentName);
+            if (!engram)
                 continue;
-            const engram = await this.repository.get(entry.name);
             targets.push({
-                engramId: entry.name,
-                agentPath,
-                hasEngram: engram !== null,
+                engramId: agentName,
+                workspacePath: join(baseDir, entry.name),
             });
         }
         return targets;
     }
+    /**
+     * 全 workspace のエージェント名一覧
+     */
+    async scanAllWorkspaces(baseDir) {
+        const entries = await readdir(baseDir, { withFileTypes: true });
+        const names = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const agentName = extractAgentName(entry.name);
+            if (agentName)
+                names.push(agentName);
+        }
+        return names;
+    }
 }
-export class SyncAgentsDirNotFoundError extends Error {
+export class SyncOpenclawDirNotFoundError extends Error {
     constructor(path) {
-        super(`OpenClaw agents directory not found at ${path}`);
-        this.name = "SyncAgentsDirNotFoundError";
+        super(`OpenClaw directory not found at ${path}`);
+        this.name = "SyncOpenclawDirNotFoundError";
     }
 }

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

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

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

@@ -0,0 +1,149 @@
+import { LocalEngramRepository } from "../../../adapters/local/index.js";
+import { Inject, InjectEngramNotFoundError, InjectClawDirNotFoundError, InjectWorkspaceNotFoundError, Extract, WorkspaceNotFoundError, WorkspaceEmptyError, AlreadyExtractedError, Sync, SyncOpenclawDirNotFoundError, } from "../../../core/usecases/index.js";
+import { resolveEngramsPath, resolveClawPath } from "../../../shared/config.js";
+import { resolveWorkspacePath } from "../../../shared/openclaw.js";
+export function registerClawCommand(program) {
+    const claw = program
+        .command("claw")
+        .description("Manage Claw agent workspaces (OpenClaw and compatible)");
+    // --- claw inject ---
+    claw
+        .command("inject")
+        .description("Push an Engram into a Claw workspace")
+        .requiredOption("-e, --engram <id>", "Engram ID to inject")
+        .option("--to <agent>", "Inject into a different agent name")
+        .option("--dir <dir>", "Override Claw directory path (default: ~/.openclaw)")
+        .option("--merge-identity", "Merge IDENTITY.md into SOUL.md (for non-OpenClaw Claw frameworks)")
+        .option("--no-sync", "Skip automatic memory sync after inject")
+        .option("-p, --path <dir>", "Override engrams directory path")
+        .action(async (opts) => {
+        const engramsPath = await resolveEngramsPath(opts.path);
+        const clawDir = await resolveClawPath(opts.dir);
+        const repo = new LocalEngramRepository(engramsPath);
+        const inject = new Inject(repo);
+        try {
+            const result = await inject.execute(opts.engram, {
+                to: opts.to,
+                openclawDir: clawDir,
+                mergeIdentity: opts.mergeIdentity,
+            });
+            console.log(`Injected "${result.engramName}" into ${result.targetPath}`);
+            console.log(`  Files written: ${result.filesWritten.join(", ")}`);
+            if (!opts.sync)
+                return;
+            // Auto-sync memory after inject
+            const sync = new Sync(repo, engramsPath);
+            const agentName = opts.to ?? opts.engram;
+            const workspacePath = resolveWorkspacePath(agentName, clawDir);
+            const syncResult = await sync.syncPair({
+                engramId: opts.engram,
+                workspacePath,
+            });
+            const details = [];
+            if (syncResult.memoryFilesMerged > 0) {
+                details.push(`${syncResult.memoryFilesMerged} memory file(s)`);
+            }
+            if (syncResult.memoryIndexMerged) {
+                details.push("MEMORY.md");
+            }
+            if (syncResult.userMerged) {
+                details.push("USER.md");
+            }
+            if (details.length > 0) {
+                console.log(`  Synced: ${details.join(", ")}`);
+            }
+            else {
+                console.log(`  Already in sync`);
+            }
+        }
+        catch (err) {
+            if (err instanceof InjectEngramNotFoundError ||
+                err instanceof InjectClawDirNotFoundError ||
+                err instanceof InjectWorkspaceNotFoundError) {
+                console.error(`Error: ${err.message}`);
+                process.exit(1);
+            }
+            throw err;
+        }
+    });
+    // --- claw extract ---
+    claw
+        .command("extract")
+        .description("Create a new Engram from a Claw agent workspace")
+        .option("-a, --agent <name>", "Agent name to extract from (default: main)")
+        .option("--name <name>", "Engram display name (defaults to agent name)")
+        .option("--dir <dir>", "Override Claw directory path (default: ~/.openclaw)")
+        .option("-p, --path <dir>", "Override engrams directory path")
+        .action(async (opts) => {
+        const engramsPath = await resolveEngramsPath(opts.path);
+        const clawDir = await resolveClawPath(opts.dir);
+        const repo = new LocalEngramRepository(engramsPath);
+        const extract = new Extract(repo);
+        try {
+            const agentName = opts.agent ?? "main";
+            const result = await extract.execute(agentName, {
+                name: opts.name,
+                openclawDir: clawDir,
+            });
+            console.log(`Extracted "${result.engramName}" from ${result.sourcePath}`);
+            console.log(`  Files read: ${result.filesRead.join(", ")}`);
+            console.log(`  Saved as Engram: ${result.engramId}`);
+        }
+        catch (err) {
+            if (err instanceof WorkspaceNotFoundError ||
+                err instanceof WorkspaceEmptyError ||
+                err instanceof AlreadyExtractedError) {
+                console.error(`Error: ${err.message}`);
+                process.exit(1);
+            }
+            throw err;
+        }
+    });
+    // --- claw sync ---
+    claw
+        .command("sync")
+        .description("Bidirectional memory sync between Engrams and Claw workspaces")
+        .option("--dir <dir>", "Override Claw directory path (default: ~/.openclaw)")
+        .option("-p, --path <dir>", "Override engrams directory path")
+        .action(async (opts) => {
+        const engramsPath = await resolveEngramsPath(opts.path);
+        const clawDir = await resolveClawPath(opts.dir);
+        const repo = new LocalEngramRepository(engramsPath);
+        const sync = new Sync(repo, engramsPath);
+        try {
+            const result = await sync.execute(clawDir);
+            if (result.synced.length === 0 && result.skipped.length === 0) {
+                console.log("No Claw workspaces found.");
+                return;
+            }
+            for (const s of result.synced) {
+                const details = [];
+                if (s.memoryFilesMerged > 0) {
+                    details.push(`${s.memoryFilesMerged} memory file(s)`);
+                }
+                if (s.memoryIndexMerged) {
+                    details.push("MEMORY.md");
+                }
+                if (s.userMerged) {
+                    details.push("USER.md");
+                }
+                if (details.length > 0) {
+                    console.log(`  ${s.engramId}: merged ${details.join(", ")}`);
+                }
+                else {
+                    console.log(`  ${s.engramId}: already in sync`);
+                }
+            }
+            if (result.skipped.length > 0) {
+                console.log(`  Skipped (no matching Engram): ${result.skipped.join(", ")}`);
+            }
+        }
+        catch (err) {
+            if (err instanceof SyncOpenclawDirNotFoundError) {
+                console.error(`Error: ${err.message}`);
+                process.exit(1);
+            }
+            throw err;
+        }
+    });
+}

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

@@ -43,21 +43,21 @@ export function registerConfigCommand(program) {
         await saveConfig(cfg);
         console.log(`Default Engram set to: ${engram.meta.name} (${id})`);
     });
-    // relic config openclaw-path [path]
+    // relic config claw-path [path]
     config
-        .command("openclaw-path [path]")
-        .description("Get or set the OpenClaw directory path (default: ~/.openclaw)")
+        .command("claw-path [path]")
+        .description("Get or set the Claw directory path (default: ~/.openclaw)")
         .action(async (path) => {
         await ensureInitialized();
         const cfg = await loadConfig();
         if (!path) {
             // getter
-            console.log(cfg.openclawPath ?? "(not set — using ~/.openclaw)");
+            console.log(cfg.clawPath ?? "(not set — using ~/.openclaw)");
             return;
         }
-        cfg.openclawPath = path;
+        cfg.clawPath = path;
         await saveConfig(cfg);
-        console.log(`OpenClaw path set to: ${path}`);
+        console.log(`Claw path set to: ${path}`);
     });
     // relic config memory-window [n]
     config