@ectplsm/relic 0.3.2 → 0.5.0

package/dist/core/usecases/sync.js

@@ -2,6 +2,7 @@ import { existsSync } from "node:fs";
 import { readdir, readFile, writeFile, mkdir } from "node:fs/promises";
 import { join } from "node:path";
 import { homedir } from "node:os";
+import { mergeMemoryRecords } from "../sync/memory-merge.js";
 import { extractAgentName, MEMORY_DIR } from "../../shared/openclaw.js";
 const DEFAULT_OPENCLAW_DIR = join(homedir(), ".openclaw");
 const MEMORY_INDEX = "MEMORY.md";
@@ -73,37 +74,20 @@ export class Sync {
         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++;
-            }
-            // 内容が同じ → 何もしない
+        const relicRecord = Object.fromEntries(Object.entries(relicEntries).map(([date, content]) => [`memory/${date}.md`, content]));
+        const openclawRecord = Object.fromEntries(Object.entries(openclawEntries).map(([date, content]) => [`memory/${date}.md`, content]));
+        const { merged, changedPaths } = mergeMemoryRecords(relicRecord, openclawRecord);
+        if (changedPaths.length === 0) {
+            return 0;
         }
-        return mergedCount;
+        await mkdir(relicMemDir, { recursive: true });
+        await mkdir(openclawMemDir, { recursive: true });
+        for (const [path, content] of Object.entries(merged)) {
+            const date = path.replace("memory/", "").replace(".md", "");
+            await writeFile(join(relicMemDir, `${date}.md`), content, "utf-8");
+            await writeFile(join(openclawMemDir, `${date}.md`), content, "utf-8");
+        }
+        return changedPaths.length;
     }
     /**
      * MEMORY.md を双方向マージ
@@ -123,41 +107,19 @@ export class Sync {
         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");
+        const relicRecord = relicContent ? { [filename]: relicContent } : {};
+        const openclawRecord = openclawContent ? { [filename]: openclawContent } : {};
+        const { merged, changedPaths } = mergeMemoryRecords(relicRecord, openclawRecord);
+        if (changedPaths.length > 0) {
+            const mergedContent = merged[filename];
+            if (mergedContent !== undefined) {
+                await writeFile(relicPath, mergedContent, "utf-8");
+                await writeFile(openclawPath, mergedContent, "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/ ディレクトリから日付 → 内容のマップを読む
      */

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

@@ -2,22 +2,23 @@ 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 { Inject, InjectEngramNotFoundError, InjectClawDirNotFoundError, InjectWorkspaceNotFoundError, Extract, WorkspaceNotFoundError, WorkspaceEmptyError, ClawPull, ClawPullEngramNotFoundError, ClawPullWorkspaceNotFoundError, ClawPullPersonaMissingError, Sync, SyncOpenclawDirNotFoundError, } from "../../../core/usecases/index.js";
+import { resolveEngramsPath, resolveClawPath, } from "../../../shared/config.js";
+import { printDetail, printLine } from "../output.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 push ---
     claw
-        .command("inject")
-        .description("Push an Engram into a Claw workspace")
-        .requiredOption("-e, --engram <id>", "Engram ID to inject")
+        .command("push")
+        .description("Push local Engram persona into a Claw workspace")
+        .requiredOption("-e, --engram <id>", "Engram ID to push")
         .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("-y, --yes", "Skip create/overwrite confirmation")
+        .option("--no-sync", "Skip automatic memory sync after push")
         .option("-p, --path <dir>", "Override engrams directory path")
         .action(async (opts) => {
         const engramsPath = await resolveEngramsPath(opts.path);
@@ -31,26 +32,36 @@ export function registerClawCommand(program) {
             });
             const alreadyInjected = diff.soul === "same" &&
                 (diff.identity === "same" || diff.identity === "skipped");
+            const needsCreate = !diff.targetExists ||
+                diff.soul === "missing" ||
+                diff.identity === "missing";
+            if (needsCreate && !opts.yes) {
+                const confirmed = await confirmOverwrite(`Claw workspace "${opts.engram}" does not have persona files yet. Create them from the local Relic Engram? [y/N] `);
+                if (!confirmed) {
+                    printLine("Skipped.");
+                    return;
+                }
+            }
             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);
+                !(await confirmOverwrite(`Overwrite Claw workspace "${opts.engram}" persona with the local Relic version? [y/N] `))) {
+                printLine("Skipped.");
+                return;
             }
             if (alreadyInjected) {
-                console.log(`  Already injected (${diff.targetPath})`);
+                console.log(`✅ Persona already in sync (${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(", ")}`);
+                console.log(`✅ Pushed "${result.engramName}" into ${result.targetPath}`);
+                printDetail(`Files written: ${result.filesWritten.join(", ")}`);
             }
             if (!opts.sync)
                 return;
-            // Auto-sync memory after inject
+            // Auto-sync memory after push
             const sync = new Sync(repo, engramsPath);
             const workspacePath = resolveWorkspacePath(opts.engram, clawDir);
             const syncResult = await sync.syncPair({
@@ -68,88 +79,108 @@ export function registerClawCommand(program) {
                 details.push("USER.md");
             }
             if (details.length > 0) {
-                console.log(`  Synced: ${details.join(", ")}`);
+                console.log(`✅ Memory synced: ${details.join(", ")} (${opts.engram})`);
             }
             else {
-                console.log(`  Already in sync`);
+                console.log(`✅ Memory already in sync (${opts.engram})`);
             }
         }
         catch (err) {
             if (err instanceof InjectEngramNotFoundError ||
                 err instanceof InjectClawDirNotFoundError ||
                 err instanceof InjectWorkspaceNotFoundError) {
-                console.error(`Error: ${err.message}`);
+                printError(`Error: ${err.message}`);
                 process.exit(1);
             }
             throw err;
         }
     });
-    // --- claw extract ---
+    // --- claw pull ---
     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)")
+        .command("pull")
+        .description("Pull persona from a Claw workspace into local Relic")
+        .requiredOption("-e, --engram <id>", "Engram ID to pull")
+        .option("--name <name>", "Display name to use if a new local Engram is created")
         .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("-y, --yes", "Skip create/overwrite confirmation")
+        .option("--no-sync", "Skip automatic memory sync after pull")
         .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 pull = new ClawPull(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, {
+            const engramId = opts.engram.trim();
+            const local = await repo.get(engramId);
+            if (!local) {
+                if (!opts.yes &&
+                    !(await confirmOverwrite(`Local Engram "${engramId}" does not exist. Create it from the Claw workspace? [y/N] `))) {
+                    printLine("Skipped.");
+                    return;
+                }
+                const result = await extract.execute(engramId, {
                     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}`);
+                console.log(`✅ Pulled "${result.engramName}" from ${result.sourcePath}`);
+                printDetail(`Files imported: ${result.filesRead.join(", ")}`);
+                printDetail(`Saved as Engram: ${result.engramId}`);
+                if (!opts.sync)
+                    return;
+                const syncResult = await sync.syncPair({
+                    engramId,
+                    workspacePath: result.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(`✅ Memory synced: ${details.join(", ")} (${engramId})`);
                 }
                 else {
-                    console.log(`  Files extracted: ${result.filesRead.join(", ")}`);
-                    console.log(`  Saved as Engram: ${result.engramId}`);
+                    console.log(`✅ Memory already in sync (${engramId})`);
+                }
+                return;
+            }
+            const { result, apply } = await pull.check(engramId, {
+                openclawDir: clawDir,
+            });
+            if (result.outcome === "already_synced") {
+                console.log(`✅ Persona already in sync (${engramId})`);
+            }
+            else {
+                const diff = result.diff;
+                if (diff.soulDiff === "different") {
+                    printDetail("SOUL.md: differs");
+                }
+                if (diff.identityDiff === "different") {
+                    printDetail("IDENTITY.md: differs");
+                }
+                // Confirm overwrite
+                if (!opts.yes &&
+                    !(await confirmOverwrite(`Overwrite local Engram "${engramId}" persona with the Claw workspace version? [y/N] `))) {
+                    printLine("Skipped.");
+                    return;
                 }
+                await apply();
+                console.log(`✅ Pulled "${result.engramName}" from ${result.diff.sourcePath}`);
             }
             if (!opts.sync)
                 return;
+            const workspacePath = resolveWorkspacePath(engramId, clawDir);
             const syncResult = await sync.syncPair({
-                engramId: agentName,
-                workspacePath: diff.sourcePath,
+                engramId,
+                workspacePath,
             });
             const details = [];
             if (syncResult.memoryFilesMerged > 0) {
@@ -162,17 +193,19 @@ export function registerClawCommand(program) {
                 details.push("USER.md");
             }
             if (details.length > 0) {
-                console.log(`  Synced: ${details.join(", ")}`);
+                console.log(`✅ Memory synced: ${details.join(", ")} (${engramId})`);
             }
             else {
-                console.log(`  Already in sync`);
+                console.log(`✅ Memory already in sync (${engramId})`);
             }
         }
         catch (err) {
             if (err instanceof WorkspaceNotFoundError ||
                 err instanceof WorkspaceEmptyError ||
-                err instanceof AlreadyExtractedError) {
-                console.error(`Error: ${err.message}`);
+                err instanceof ClawPullEngramNotFoundError ||
+                err instanceof ClawPullWorkspaceNotFoundError ||
+                err instanceof ClawPullPersonaMissingError) {
+                printError(`Error: ${err.message}`);
                 process.exit(1);
             }
             throw err;
@@ -182,7 +215,8 @@ 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("-e, --engram <id>", "Engram ID to sync")
+        .option("--all", "Sync all matching targets")
         .option("--dir <dir>", "Override Claw directory path (default: ~/.openclaw)")
         .option("-p, --path <dir>", "Override engrams directory path")
         .action(async (opts) => {
@@ -191,24 +225,32 @@ 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}".`);
+            if (opts.engram && opts.all) {
+                printError("Error: --engram and --all cannot be used together.");
+                process.exit(1);
+            }
+            if (!opts.engram && !opts.all) {
+                printError("Error: Specify --engram <id> or --all.");
+                process.exit(1);
+            }
+            if (opts.engram) {
+                const engramId = opts.engram.trim();
+                if (!engramId) {
+                    printError(`Error: Invalid Engram ID "${opts.engram}".`);
                     process.exit(1);
                 }
-                const engram = await repo.get(targetId);
+                const engram = await repo.get(engramId);
                 if (!engram) {
-                    console.error(`Error: Engram "${targetId}" not found.`);
+                    printError(`Error: Engram "${engramId}" not found.`);
                     process.exit(1);
                 }
-                const workspacePath = resolveWorkspacePath(targetId, clawDir);
+                const workspacePath = resolveWorkspacePath(engramId, clawDir);
                 if (!existsSync(workspacePath)) {
-                    console.error(`Error: Claw agent "${targetId}" workspace not found.`);
+                    printError(`Error: Claw agent "${engramId}" workspace not found.`);
                     process.exit(1);
                 }
                 const result = await sync.syncPair({
-                    engramId: targetId,
+                    engramId,
                     workspacePath,
                 });
                 const details = [];
@@ -222,16 +264,16 @@ export function registerClawCommand(program) {
                     details.push("USER.md");
                 }
                 if (details.length > 0) {
-                    console.log(`  ${targetId}: merged ${details.join(", ")}`);
+                    console.log(`✅ ${engramId}: merged ${details.join(", ")}`);
                 }
                 else {
-                    console.log(`  Already in sync (${targetId})`);
+                    console.log(`✅ Already in sync (${engramId})`);
                 }
                 return;
             }
             const result = await sync.execute(clawDir);
             if (result.synced.length === 0 && result.skipped.length === 0) {
-                console.log("No Claw workspaces found.");
+                printLine("No Claw workspaces found.");
                 return;
             }
             for (const s of result.synced) {
@@ -246,19 +288,19 @@ export function registerClawCommand(program) {
                     details.push("USER.md");
                 }
                 if (details.length > 0) {
-                    console.log(`  ${s.engramId}: merged ${details.join(", ")}`);
+                    console.log(`✅ ${s.engramId}: merged ${details.join(", ")}`);
                 }
                 else {
-                    console.log(`  Already in sync (${s.engramId})`);
+                    console.log(`✅ Already in sync (${s.engramId})`);
                 }
             }
             if (result.skipped.length > 0) {
-                console.log(`  Skipped (no matching Engram): ${result.skipped.join(", ")}`);
+                console.log(`Skipped (no matching Engram): ${result.skipped.join(", ")}`);
             }
         }
         catch (err) {
             if (err instanceof SyncOpenclawDirNotFoundError) {
-                console.error(`Error: ${err.message}`);
+                printError(`Error: ${err.message}`);
                 process.exit(1);
             }
             throw err;
@@ -278,3 +320,10 @@ async function confirmOverwrite(message) {
         rl.close();
     }
 }
+// ---------------------------------------------------------------------------
+// ANSI colors
+// ---------------------------------------------------------------------------
+const red = (s) => `\x1b[31m${s}\x1b[0m`;
+function printError(msg) {
+    console.error(red(msg));
+}

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

@@ -80,10 +80,69 @@ export function registerConfigCommand(program) {
         await saveConfig(cfg);
         console.log(`Memory window set to: ${parsed}`);
     });
+    // relic config mikoshi-url [url]
+    config
+        .command("mikoshi-url [url]")
+        .description("Get or set the Mikoshi API base URL (default: https://mikoshi.ectplsm.com)")
+        .action(async (url) => {
+        await ensureInitialized();
+        const cfg = await loadConfig();
+        if (!url) {
+            console.log(cfg.mikoshiUrl);
+            return;
+        }
+        cfg.mikoshiUrl = url;
+        await saveConfig(cfg);
+        console.log(`Mikoshi URL set to: ${url}`);
+    });
+    // relic config mikoshi-api-key [key]
+    config
+        .command("mikoshi-api-key [key]")
+        .description("Get or set the Mikoshi API key")
+        .action(async (key) => {
+        await ensureInitialized();
+        const cfg = await loadConfig();
+        if (!key) {
+            if (cfg.mikoshiApiKey) {
+                // マスク表示 — 先頭10文字だけ見せる
+                const masked = cfg.mikoshiApiKey.length > 10
+                    ? cfg.mikoshiApiKey.slice(0, 10) + "…"
+                    : cfg.mikoshiApiKey;
+                console.log(masked);
+            }
+            else {
+                console.log("(not set)");
+            }
+            return;
+        }
+        cfg.mikoshiApiKey = key;
+        await saveConfig(cfg);
+        console.log("Mikoshi API key saved.");
+    });
+    // relic config mikoshi-passphrase [value]
+    config
+        .command("mikoshi-passphrase [value]")
+        .description("Get or set the passphrase for Mikoshi memory encryption")
+        .action(async (value) => {
+        await ensureInitialized();
+        const cfg = await loadConfig();
+        if (!value) {
+            if (cfg.mikoshiPassphrase) {
+                console.log("(set)");
+            }
+            else {
+                console.log("(not set)");
+            }
+            return;
+        }
+        cfg.mikoshiPassphrase = value;
+        await saveConfig(cfg);
+        console.log("Mikoshi passphrase saved.");
+    });
     // relic config distillation-batch-size [n]
     config
         .command("distillation-batch-size [n]")
-        .description("Get or set the number of archive entries to distill at once (default: 30)")
+        .description("Get or set the number of archive entries to distill at once (default: 100)")
         .action(async (n) => {
         await ensureInitialized();
         const cfg = await loadConfig();

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

@@ -3,6 +3,7 @@ import { stdin as input, stdout as output } from "node:process";
 import { loadConfig, ensureInitialized } from "../../../shared/config.js";
 import { LocalEngramRepository } from "../../../adapters/local/index.js";
 import { DEFAULT_SOUL, DEFAULT_IDENTITY } from "../../../shared/templates.js";
+import { printBlank, printDetail, printLine } from "../output.js";
 import { CreateEngram, EngramAlreadyExistsError, InvalidEngramIdError, ENGRAM_ID_PATTERN, } from "../../../core/usecases/create-engram.js";
 // ============================================================
 // Interactive prompt helpers
@@ -16,7 +17,7 @@ async function askRequired(rl, question, errorMsg) {
         const answer = await ask(rl, question);
         if (answer)
             return answer;
-        console.log(errorMsg);
+        printLine(errorMsg);
     }
 }
 /**
@@ -24,14 +25,14 @@ async function askRequired(rl, question, errorMsg) {
  */
 async function askValidId(rl, repo) {
     while (true) {
-        const id = await askRequired(rl, "Engram ID (e.g. my-agent): ", "  ID is required. Use lowercase letters, numbers, and hyphens.");
+        const id = await askRequired(rl, "Engram ID (e.g. my-agent): ", "ID is required. Use lowercase letters, numbers, and hyphens.");
         if (!ENGRAM_ID_PATTERN.test(id)) {
-            console.log("  Invalid ID. Use lowercase letters, numbers, and hyphens (e.g. my-agent).");
+            printLine("Invalid ID. Use lowercase letters, numbers, and hyphens (e.g. my-agent).");
             continue;
         }
         const existing = await repo.get(id);
         if (existing) {
-            console.log(`  Engram "${id}" already exists. Choose a different ID.`);
+            printLine(`Engram "${id}" already exists. Choose a different ID.`);
             continue;
         }
         return id;
@@ -91,7 +92,7 @@ export function registerCreateCommand(program) {
                     id = await askValidId(rl, repo);
                 }
                 if (!name) {
-                    name = await askRequired(rl, "Name: ", "  Name is required.");
+                    name = await askRequired(rl, "Name: ", "Name is required.");
                 }
                 if (description === undefined) {
                     description = await ask(rl, "Description (optional): ") || undefined;
@@ -119,17 +120,17 @@ export function registerCreateCommand(program) {
             });
             const green = (s) => `\x1b[32m${s}\x1b[0m`;
             const engramDir = `${config.engramsPath}/${result.engram.meta.id}`;
-            console.log();
-            console.log(green(`Created Engram "${result.engram.meta.name}" (${result.engram.meta.id})`));
-            console.log(`  → ${engramDir}/`);
-            console.log();
-            console.log("Files:");
-            console.log("  engram.json    — metadata (name, description, tags)");
-            console.log("  manifest.json  — system metadata (id, timestamps)");
-            console.log("  SOUL.md        — core principles and behavior");
-            console.log("  IDENTITY.md    — persona identity (fill in during first conversation)");
-            console.log();
-            console.log(`Customize SOUL.md and IDENTITY.md, then run: relic claude ${result.engram.meta.id}`);
+            printBlank();
+            printLine(green(`Created Engram "${result.engram.meta.name}" (${result.engram.meta.id})`));
+            printDetail(`→ ${engramDir}/`);
+            printBlank();
+            printLine("Files:");
+            printDetail("engram.json    — metadata (name, description, tags)");
+            printDetail("manifest.json  — system metadata (id, timestamps)");
+            printDetail("SOUL.md        — core principles and behavior");
+            printDetail("IDENTITY.md    — persona identity (fill in during first conversation)");
+            printBlank();
+            printLine(`Customize SOUL.md and IDENTITY.md, then run: relic claude ${result.engram.meta.id}`);
         }
         catch (err) {
             if (err instanceof InvalidEngramIdError || err instanceof EngramAlreadyExistsError) {