@ectplsm/relic 0.1.3 → 0.2.0

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

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

@@ -1,38 +1,33 @@
 import { LocalEngramRepository } from "../../../adapters/local/index.js";
-import { Extract, WorkspaceNotFoundError, WorkspaceEmptyError, EngramAlreadyExistsError, ExtractNameRequiredError, } from "../../../core/usecases/index.js";
+import { Extract, WorkspaceNotFoundError, WorkspaceEmptyError, AlreadyExtractedError, } from "../../../core/usecases/index.js";
 import { resolveEngramsPath, resolveOpenclawPath } from "../../../shared/config.js";
 export function registerExtractCommand(program) {
     program
         .command("extract")
-        .description("Extract an Engram from an OpenClaw workspace")
-        .requiredOption("-e, --engram <id>", "Engram ID (= agent name)")
-        .option("--name <name>", "Engram display name (required for new Engrams)")
+        .description("Create a new Engram from an OpenClaw agent workspace")
+        .option("-a, --agent <name>", "OpenClaw agent name to extract from (default: main)")
+        .option("--name <name>", "Engram display name (defaults to agent name)")
         .option("--openclaw <dir>", "Override OpenClaw directory path (default: ~/.openclaw)")
         .option("-p, --path <dir>", "Override engrams directory path")
-        .option("-f, --force", "Overwrite existing Engram persona files")
         .action(async (opts) => {
         const engramsPath = await resolveEngramsPath(opts.path);
         const openclawDir = await resolveOpenclawPath(opts.openclaw);
         const repo = new LocalEngramRepository(engramsPath);
         const extract = new Extract(repo);
         try {
-            const result = await extract.execute(opts.engram, {
+            const agentName = opts.agent ?? "main";
+            const result = await extract.execute(agentName, {
                 name: opts.name,
                 openclawDir,
-                force: opts.force,
             });
             console.log(`Extracted "${result.engramName}" from ${result.sourcePath}`);
             console.log(`  Files read: ${result.filesRead.join(", ")}`);
             console.log(`  Saved as Engram: ${result.engramId}`);
-            if (result.memoryMerged) {
-                console.log(`  Memory entries merged into existing Engram`);
-            }
         }
         catch (err) {
             if (err instanceof WorkspaceNotFoundError ||
                 err instanceof WorkspaceEmptyError ||
-                err instanceof EngramAlreadyExistsError ||
-                err instanceof ExtractNameRequiredError) {
+                err instanceof AlreadyExtractedError) {
                 console.error(`Error: ${err.message}`);
                 process.exit(1);
             }

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

@@ -1,5 +1,5 @@
 import { LocalEngramRepository } from "../../../adapters/local/index.js";
-import { Inject, InjectEngramNotFoundError, InjectAgentNotFoundError, } from "../../../core/usecases/index.js";
+import { Inject, InjectEngramNotFoundError, InjectWorkspaceNotFoundError, } from "../../../core/usecases/index.js";
 import { resolveEngramsPath, resolveOpenclawPath } from "../../../shared/config.js";
 export function registerInjectCommand(program) {
     program
@@ -24,7 +24,7 @@ export function registerInjectCommand(program) {
         }
         catch (err) {
             if (err instanceof InjectEngramNotFoundError ||
-                err instanceof InjectAgentNotFoundError) {
+                err instanceof InjectWorkspaceNotFoundError) {
                 console.error(`Error: ${err.message}`);
                 process.exit(1);
             }

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

@@ -1,51 +1,43 @@
-import { watch } from "node:fs";
-import { join } from "node:path";
 import { LocalEngramRepository } from "../../../adapters/local/index.js";
-import { Sync, SyncAgentsDirNotFoundError, } from "../../../core/usecases/index.js";
+import { Sync, SyncOpenclawDirNotFoundError, } from "../../../core/usecases/index.js";
 import { resolveEngramsPath } from "../../../shared/config.js";
 export function registerSyncCommand(program) {
     program
         .command("sync")
-        .description("Watch OpenClaw agents and auto-sync with Engrams")
+        .description("Bidirectional memory sync between Relic Engrams and OpenClaw workspaces")
         .option("--openclaw <dir>", "Override OpenClaw directory path (default: ~/.openclaw)")
         .option("-p, --path <dir>", "Override engrams directory path")
         .action(async (opts) => {
         const engramsPath = await resolveEngramsPath(opts.path);
         const repo = new LocalEngramRepository(engramsPath);
-        const sync = new Sync(repo);
+        const sync = new Sync(repo, engramsPath);
         try {
-            console.log("Starting Relic sync...");
-            // 初回同期
-            const result = await sync.initialSync(opts.openclaw);
-            if (result.injected.length > 0) {
-                console.log(`  Injected: ${result.injected.join(", ")}`);
-            }
-            if (result.extracted.length > 0) {
-                console.log(`  Extracted memory: ${result.extracted.join(", ")}`);
-            }
-            if (result.targets.length === 0) {
-                console.log("  No agents found.");
+            const result = await sync.execute(opts.openclaw);
+            if (result.synced.length === 0 && result.skipped.length === 0) {
+                console.log("No OpenClaw workspaces found.");
                 return;
             }
-            // ファイル監視を開始
-            const watchers = startWatching(result.targets, sync, opts.openclaw);
-            console.log(`\nWatching ${result.targets.length} agent(s) for memory changes...`);
-            console.log("Press Ctrl+C to stop.\n");
-            // Ctrl+C でクリーンアップ
-            const cleanup = () => {
-                console.log("\nStopping sync...");
-                for (const w of watchers) {
-                    w.close();
+            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");
                 }
-                process.exit(0);
-            };
-            process.on("SIGINT", cleanup);
-            process.on("SIGTERM", cleanup);
-            // プロセスを維持
-            await new Promise(() => { });
+                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 SyncAgentsDirNotFoundError) {
+            if (err instanceof SyncOpenclawDirNotFoundError) {
                 console.error(`Error: ${err.message}`);
                 process.exit(1);
             }
@@ -53,39 +45,3 @@ export function registerSyncCommand(program) {
         }
     });
 }
-function startWatching(targets, sync, openclawDir) {
-    const watchers = [];
-    // デバウンス用タイマー
-    const debounceTimers = new Map();
-    for (const target of targets) {
-        const memoryDir = join(target.agentPath, "memory");
-        try {
-            const watcher = watch(memoryDir, { recursive: true }, (_event, filename) => {
-                if (!filename?.endsWith(".md"))
-                    return;
-                // デバウンス（同一agentの連続変更を500msでまとめる）
-                const existing = debounceTimers.get(target.engramId);
-                if (existing)
-                    clearTimeout(existing);
-                debounceTimers.set(target.engramId, setTimeout(async () => {
-                    debounceTimers.delete(target.engramId);
-                    try {
-                        await sync.syncMemory(target.engramId, openclawDir);
-                        const now = new Date().toLocaleTimeString();
-                        console.log(`[${now}] Synced memory: ${target.engramId} (${filename})`);
-                    }
-                    catch {
-                        // sync失敗は警告のみ
-                        console.error(`[warn] Failed to sync memory for ${target.engramId}`);
-                    }
-                }, 500));
-            });
-            watchers.push(watcher);
-        }
-        catch {
-            // memory/ ディレクトリが存在しない場合はスキップ
-            // （エージェントにまだメモリがない）
-        }
-    }
-    return watchers;
-}

package/dist/interfaces/cli/index.js

@@ -7,9 +7,7 @@ import { registerInitCommand } from "./commands/init.js";
 import { registerListCommand } from "./commands/list.js";
 import { registerShowCommand } from "./commands/show.js";
 import { registerShellCommands } from "./commands/shell.js";
-import { registerInjectCommand } from "./commands/inject.js";
-import { registerExtractCommand } from "./commands/extract.js";
-import { registerSyncCommand } from "./commands/sync.js";
+import { registerClawCommand } from "./commands/claw.js";
 import { registerConfigCommand } from "./commands/config.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(resolve(__dirname, "../../../package.json"), "utf-8"));
@@ -22,8 +20,6 @@ registerInitCommand(program);
 registerListCommand(program);
 registerShowCommand(program);
 registerShellCommands(program);
-registerInjectCommand(program);
-registerExtractCommand(program);
-registerSyncCommand(program);
+registerClawCommand(program);
 registerConfigCommand(program);
 program.parse();