@ectplsm/relic 0.1.4 → 0.2.1

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,280 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { existsSync } from "node:fs";
+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("--dir <dir>", "Override Claw directory path (default: ~/.openclaw)")
+        .option("--merge-identity", "Merge IDENTITY.md into SOUL.md (for non-OpenClaw Claw frameworks)")
+        .option("-y, --yes", "Skip persona overwrite confirmation")
+        .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 diff = await inject.inspectPersona(opts.engram, {
+                openclawDir: clawDir,
+                mergeIdentity: opts.mergeIdentity,
+            });
+            const alreadyInjected = diff.soul === "same" &&
+                (diff.identity === "same" || diff.identity === "skipped");
+            if (diff.overwriteRequired &&
+                !opts.yes &&
+                !(await confirmOverwrite(`SOUL.md and/or IDENTITY.md already exist and differ in ${diff.targetPath}. Overwrite with local Relic version? [y/N] `))) {
+                console.error("Error: Persona files already exist and differ. Re-run with --yes to overwrite from local Relic Engram.");
+                process.exit(1);
+            }
+            if (alreadyInjected) {
+                console.log(`  Already injected (${diff.targetPath})`);
+            }
+            else {
+                const result = await inject.execute(opts.engram, {
+                    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 workspacePath = resolveWorkspacePath(opts.engram, 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("-f, --force", "Allow overwriting local persona files from the Claw workspace")
+        .option("-y, --yes", "Skip persona overwrite confirmation")
+        .option("--no-sync", "Skip automatic memory sync after extract")
+        .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);
+        const sync = new Sync(repo, engramsPath);
+        try {
+            const agentName = opts.agent ?? "main";
+            const diff = await extract.inspectPersona(agentName, {
+                name: opts.name,
+                openclawDir: clawDir,
+            });
+            if (diff.existing && !opts.force) {
+                throw new AlreadyExtractedError(agentName);
+            }
+            const alreadyExtracted = diff.existing &&
+                diff.name === "same" &&
+                diff.soul === "same" &&
+                diff.identity === "same";
+            if (diff.existing &&
+                diff.overwriteRequired &&
+                !opts.yes &&
+                !(await confirmOverwrite(`SOUL.md and/or IDENTITY.md already exist in local Engram "${agentName}" and differ from ${diff.sourcePath}. Overwrite with the Claw version? [y/N] `))) {
+                console.error("Error: Persona files already exist and differ. Re-run with --yes to overwrite from the Claw workspace.");
+                process.exit(1);
+            }
+            if (alreadyExtracted) {
+                console.log(opts.force
+                    ? `  Already extracted and updated (${agentName})`
+                    : `  Already extracted (${agentName})`);
+            }
+            else {
+                const result = await extract.execute(agentName, {
+                    name: opts.name,
+                    openclawDir: clawDir,
+                    force: opts.force,
+                });
+                console.log(`Extracted "${result.engramName}" from ${result.sourcePath}`);
+                if (diff.existing) {
+                    console.log(`  Files overwritten: SOUL.md, IDENTITY.md`);
+                    if (diff.name === "different") {
+                        console.log(`  Metadata updated: engram.json (name)`);
+                    }
+                    console.log(`  Saved as Engram: ${result.engramId}`);
+                }
+                else {
+                    console.log(`  Files extracted: ${result.filesRead.join(", ")}`);
+                    console.log(`  Saved as Engram: ${result.engramId}`);
+                }
+            }
+            if (!opts.sync)
+                return;
+            const syncResult = await sync.syncPair({
+                engramId: agentName,
+                workspacePath: diff.sourcePath,
+            });
+            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 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("-t, --target <id>", "Sync one target only by shared Engram/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 sync = new Sync(repo, engramsPath);
+        try {
+            if (opts.target) {
+                const targetId = opts.target.trim();
+                if (!targetId) {
+                    console.error(`Error: Invalid sync target "${opts.target}".`);
+                    process.exit(1);
+                }
+                const engram = await repo.get(targetId);
+                if (!engram) {
+                    console.error(`Error: Engram "${targetId}" not found.`);
+                    process.exit(1);
+                }
+                const workspacePath = resolveWorkspacePath(targetId, clawDir);
+                if (!existsSync(workspacePath)) {
+                    console.error(`Error: Claw agent "${targetId}" workspace not found.`);
+                    process.exit(1);
+                }
+                const result = await sync.syncPair({
+                    engramId: targetId,
+                    workspacePath,
+                });
+                const details = [];
+                if (result.memoryFilesMerged > 0) {
+                    details.push(`${result.memoryFilesMerged} memory file(s)`);
+                }
+                if (result.memoryIndexMerged) {
+                    details.push("MEMORY.md");
+                }
+                if (result.userMerged) {
+                    details.push("USER.md");
+                }
+                if (details.length > 0) {
+                    console.log(`  ${targetId}: merged ${details.join(", ")}`);
+                }
+                else {
+                    console.log(`  Already in sync (${targetId})`);
+                }
+                return;
+            }
+            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(`  Already in sync (${s.engramId})`);
+                }
+            }
+            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;
+        }
+    });
+}
+async function confirmOverwrite(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();
+    }
+}

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);
             }