@ectplsm/relic 0.2.0 → 0.2.2

package/dist/core/usecases/extract.js

@@ -13,41 +13,95 @@ export class Extract {
     constructor(repository) {
         this.repository = repository;
     }
+    async inspectPersona(agentName, options) {
+        const sourcePath = resolveWorkspacePath(agentName, options?.openclawDir);
+        if (!existsSync(sourcePath)) {
+            throw new WorkspaceNotFoundError(sourcePath);
+        }
+        const { files } = await this.readFiles(sourcePath);
+        const existing = await this.repository.get(agentName);
+        if (!existing) {
+            return {
+                engramId: agentName,
+                engramName: options?.name ?? agentName,
+                sourcePath,
+                existing: false,
+                name: "missing",
+                soul: "missing",
+                identity: "missing",
+                overwriteRequired: false,
+            };
+        }
+        const requestedName = options?.name ?? existing.meta.name;
+        const name = requestedName === existing.meta.name ? "same" : "different";
+        const soul = this.comparePersonaFile(existing.files.soul, files.soul);
+        const identity = this.comparePersonaFile(existing.files.identity, files.identity);
+        return {
+            engramId: agentName,
+            engramName: existing.meta.name,
+            sourcePath,
+            existing: true,
+            name,
+            soul,
+            identity,
+            overwriteRequired: name === "different" ||
+                soul === "different" ||
+                identity === "different",
+        };
+    }
     async execute(agentName, options) {
         const sourcePath = resolveWorkspacePath(agentName, options?.openclawDir);
         if (!existsSync(sourcePath)) {
             throw new WorkspaceNotFoundError(sourcePath);
         }
-        // 既存Engramがあればエラー — Relic側が真のデータソース
         const existing = await this.repository.get(agentName);
-        if (existing) {
+        if (existing && !options?.force) {
             throw new AlreadyExtractedError(agentName);
         }
         const { files, filesRead } = await this.readFiles(sourcePath);
         if (filesRead.length === 0) {
             throw new WorkspaceEmptyError(sourcePath);
         }
-        const engramName = options?.name ?? agentName;
         const now = new Date().toISOString();
-        const engram = {
-            meta: {
-                id: agentName,
-                name: engramName,
-                description: `Extracted from OpenClaw workspace (${agentName})`,
-                createdAt: now,
-                updatedAt: now,
-                tags: ["extracted", "openclaw"],
-            },
-            files,
-        };
+        const engram = existing && options?.force
+            ? {
+                meta: {
+                    ...existing.meta,
+                    name: options?.name ?? existing.meta.name,
+                    updatedAt: now,
+                },
+                // Force extract only replaces persona files from Claw.
+                files: {
+                    ...existing.files,
+                    soul: files.soul ?? existing.files.soul,
+                    identity: files.identity ?? existing.files.identity,
+                },
+            }
+            : {
+                meta: {
+                    id: agentName,
+                    name: options?.name ?? agentName,
+                    description: `Extracted from OpenClaw workspace (${agentName})`,
+                    createdAt: now,
+                    updatedAt: now,
+                    tags: ["extracted", "openclaw"],
+                },
+                files,
+            };
         await this.repository.save(engram);
         return {
             engramId: agentName,
-            engramName,
+            engramName: engram.meta.name,
             sourcePath,
             filesRead,
         };
     }
+    comparePersonaFile(currentContent, incomingContent) {
+        if (currentContent === undefined || incomingContent === undefined) {
+            return "missing";
+        }
+        return currentContent === incomingContent ? "same" : "different";
+    }
     async readFiles(sourcePath) {
         const files = {};
         const filesRead = [];
@@ -88,7 +142,7 @@ export class WorkspaceEmptyError extends Error {
 }
 export class AlreadyExtractedError extends Error {
     constructor(id) {
-        super(`Engram "${id}" already exists. Relic is the source of truth — use "relic claw inject" to push changes.`);
+        super(`Engram "${id}" already exists. Re-run with "--force" option to overwrite local persona files from the Claw workspace.`);
         this.name = "AlreadyExtractedError";
     }
 }

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

@@ -1,8 +1,10 @@
 export { Summon, EngramNotFoundError, type SummonResult } from "./summon.js";
 export { ListEngrams } from "./list-engrams.js";
 export { Init, type InitResult } from "./init.js";
-export { Inject, InjectEngramNotFoundError, InjectClawDirNotFoundError, InjectWorkspaceNotFoundError, type InjectResult, } from "./inject.js";
-export { Extract, WorkspaceNotFoundError, WorkspaceEmptyError, AlreadyExtractedError, type ExtractResult, } from "./extract.js";
+export { MigrateEngrams, type MigrateEngramsResult, } from "./migrate-engrams.js";
+export { RefreshSamples, type RefreshSamplesResult, } from "./refresh-samples.js";
+export { Inject, InjectEngramNotFoundError, InjectClawDirNotFoundError, InjectWorkspaceNotFoundError, type InjectPersonaFileDiff, type InjectPersonaDiffResult, type InjectResult, } from "./inject.js";
+export { Extract, WorkspaceNotFoundError, WorkspaceEmptyError, AlreadyExtractedError, type ExtractPersonaFileDiff, type ExtractPersonaDiffResult, type ExtractResult, } from "./extract.js";
 export { MemoryWrite, MemoryWriteEngramNotFoundError, type MemoryWriteResult, } from "./memory-write.js";
 export { Sync, SyncOpenclawDirNotFoundError, type SyncTarget, type SyncResult, type SyncInitialResult, } from "./sync.js";
 export { ArchivePending, ArchivePendingEngramNotFoundError, type ArchivePendingResult, } from "./archive-pending.js";

package/dist/core/usecases/index.js

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

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

@@ -1,4 +1,13 @@
 import type { EngramRepository } from "../ports/engram-repository.js";
+export type InjectPersonaFileDiff = "missing" | "same" | "different" | "skipped";
+export interface InjectPersonaDiffResult {
+    engramId: string;
+    engramName: string;
+    targetPath: string;
+    soul: InjectPersonaFileDiff;
+    identity: InjectPersonaFileDiff;
+    overwriteRequired: boolean;
+}
 export interface InjectResult {
     engramId: string;
     engramName: string;
@@ -15,11 +24,17 @@ export interface InjectResult {
 export declare class Inject {
     private readonly repository;
     constructor(repository: EngramRepository);
+    inspectPersona(engramId: string, options?: {
+        openclawDir?: string;
+        mergeIdentity?: boolean;
+    }): Promise<InjectPersonaDiffResult>;
     execute(engramId: string, options?: {
-        to?: string;
         openclawDir?: string;
         mergeIdentity?: boolean;
     }): Promise<InjectResult>;
+    private loadInjectTarget;
+    private resolveInjectedContent;
+    private compareTargetFile;
     private writeFiles;
 }
 export declare class InjectEngramNotFoundError extends Error {

package/dist/core/usecases/inject.js

@@ -1,6 +1,6 @@
 import { join } from "node:path";
 import { existsSync } from "node:fs";
-import { writeFile } from "node:fs/promises";
+import { readFile, writeFile } from "node:fs/promises";
 import { INJECT_FILE_MAP, resolveWorkspacePath } from "../../shared/openclaw.js";
 /**
  * Inject — EngramのファイルをOpenClawワークスペースに注入する
@@ -14,27 +14,65 @@ export class Inject {
     constructor(repository) {
         this.repository = repository;
     }
+    async inspectPersona(engramId, options) {
+        const { engram, targetPath } = await this.loadInjectTarget(engramId, options);
+        const mergeIdentity = options?.mergeIdentity ?? false;
+        const soul = await this.compareTargetFile(join(targetPath, INJECT_FILE_MAP.soul), this.resolveInjectedContent("soul", engram.files, mergeIdentity));
+        const identity = mergeIdentity
+            ? "skipped"
+            : await this.compareTargetFile(join(targetPath, INJECT_FILE_MAP.identity), this.resolveInjectedContent("identity", engram.files, mergeIdentity));
+        return {
+            engramId: engram.meta.id,
+            engramName: engram.meta.name,
+            targetPath,
+            soul,
+            identity,
+            overwriteRequired: soul === "different" || identity === "different",
+        };
+    }
     async execute(engramId, options) {
+        const { engram, targetPath } = await this.loadInjectTarget(engramId, options);
+        const filesWritten = await this.writeFiles(targetPath, engram.files, options?.mergeIdentity ?? false);
+        return {
+            engramId: engram.meta.id,
+            engramName: engram.meta.name,
+            targetPath,
+            filesWritten,
+        };
+    }
+    async loadInjectTarget(engramId, options) {
         const engram = await this.repository.get(engramId);
         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 = resolveWorkspacePath(agentName, options?.openclawDir);
+        const targetPath = resolveWorkspacePath(engramId, options?.openclawDir);
         if (!existsSync(targetPath)) {
-            throw new InjectWorkspaceNotFoundError(agentName);
+            throw new InjectWorkspaceNotFoundError(engramId);
         }
-        const filesWritten = await this.writeFiles(targetPath, engram.files, options?.mergeIdentity ?? false);
-        return {
-            engramId: engram.meta.id,
-            engramName: engram.meta.name,
-            targetPath,
-            filesWritten,
-        };
+        return { engram, targetPath };
+    }
+    resolveInjectedContent(key, files, mergeIdentity) {
+        if (mergeIdentity && key === "identity") {
+            return undefined;
+        }
+        let content = files[key];
+        if (mergeIdentity && key === "soul" && files.identity) {
+            content = content + "\n" + files.identity;
+        }
+        return content;
+    }
+    async compareTargetFile(filePath, expectedContent) {
+        if (expectedContent === undefined) {
+            return "skipped";
+        }
+        if (!existsSync(filePath)) {
+            return "missing";
+        }
+        const currentContent = await readFile(filePath, "utf-8");
+        return currentContent === expectedContent ? "same" : "different";
     }
     async writeFiles(targetPath, files, mergeIdentity) {
         const written = [];
@@ -43,11 +81,7 @@ export class Inject {
             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;
-            }
+            const content = this.resolveInjectedContent(key, files, mergeIdentity);
             if (content !== undefined) {
                 await writeFile(join(targetPath, filename), content, "utf-8");
                 written.push(filename);

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

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

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

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

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

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

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

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

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

@@ -1,3 +1,6 @@
+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";
@@ -11,9 +14,9 @@ export function registerClawCommand(program) {
         .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("-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) => {
@@ -22,19 +25,34 @@ export function registerClawCommand(program) {
         const repo = new LocalEngramRepository(engramsPath);
         const inject = new Inject(repo);
         try {
-            const result = await inject.execute(opts.engram, {
-                to: opts.to,
+            const diff = await inject.inspectPersona(opts.engram, {
                 openclawDir: clawDir,
                 mergeIdentity: opts.mergeIdentity,
             });
-            console.log(`Injected "${result.engramName}" into ${result.targetPath}`);
-            console.log(`  Files written: ${result.filesWritten.join(", ")}`);
+            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 agentName = opts.to ?? opts.engram;
-            const workspacePath = resolveWorkspacePath(agentName, clawDir);
+            const workspacePath = resolveWorkspacePath(opts.engram, clawDir);
             const syncResult = await sync.syncPair({
                 engramId: opts.engram,
                 workspacePath,
@@ -73,21 +91,82 @@ export function registerClawCommand(program) {
         .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 result = await extract.execute(agentName, {
+            const diff = await extract.inspectPersona(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}`);
+            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 ||
@@ -103,6 +182,7 @@ export function registerClawCommand(program) {
     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) => {
@@ -111,6 +191,44 @@ export function registerClawCommand(program) {
         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.");
@@ -131,7 +249,7 @@ export function registerClawCommand(program) {
                     console.log(`  ${s.engramId}: merged ${details.join(", ")}`);
                 }
                 else {
-                    console.log(`  ${s.engramId}: already in sync`);
+                    console.log(`  Already in sync (${s.engramId})`);
                 }
             }
             if (result.skipped.length > 0) {
@@ -147,3 +265,16 @@ export function registerClawCommand(program) {
         }
     });
 }
+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/migrate.d.ts

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