@ectplsm/relic 0.1.4 → 0.2.0

package/README.md

@@ -13,9 +13,28 @@
 
 **Inject a unified AI persona with persistent memory into any coding CLI.**
 
-Relic manages AI **Engrams** (memory + personality) and injects them into coding assistants like Claude Code, Codex CLI, Gemini CLI. One persona, any shell.
+Relic manages AI **Engrams** (memory + personality) and injects them into coding assistants like Claude Code, Codex CLI, Gemini CLI. Also integrates with OpenClaw and other Claw-based agent frameworks. One persona, any shell.
 
-## Installation
+## Table of Contents
+
+- [Install](#install)
+- [Quick Start](#quick-start)
+- [What `relic init` Creates](#what-relic-init-creates)
+- [Sample Engrams](#sample-engrams)
+- [How It Works](#how-it-works)
+- [Supported Shells](#supported-shells)
+- [Conversation Log Recording](#conversation-log-recording)
+- [MCP Server](#mcp-server)
+- [Claw Integration](#claw-integration)
+- [Memory Management](#memory-management)
+- [Configuration](#configuration)
+- [Creating Your Own Engram](#creating-your-own-engram)
+- [Domain Glossary](#domain-glossary)
+- [Roadmap](#roadmap)
+
+## Install
+
+<img alt="version badge" src="https://img.shields.io/github/v/release/ectplsm/relic?filter=*.*.*">
 
 ```bash
 npm install -g @ectplsm/relic
@@ -66,7 +85,7 @@ Running `relic init` creates `~/.relic/`, writes `config.json`, and seeds two sa
             └── YYYY-MM-DD.md
 ```
 
-- `config.json` stores global Relic settings such as `engramsPath`, `defaultEngram`, `openclawPath`, and `memoryWindowSize`.
+- `config.json` stores global Relic settings such as `engramsPath`, `defaultEngram`, `clawPath`, and `memoryWindowSize`.
 - `engrams/<id>/` is one Engram workspace. This is where persona files and memory for that Engram live.
 - `engram.json` stores metadata like the Engram's ID, display name, description, and tags.
 - `SOUL.md` and `IDENTITY.md` define the persona itself.
@@ -76,11 +95,14 @@ As you keep using an Engram, more files are added to the same workspace:
 
 - `archive.md` is created inside `engrams/<id>/` when shell hooks start logging raw conversation turns.
 - `MEMORY.md` can be created or extended when especially important distilled facts are promoted to long-term memory.
+- `USER.md` is created or updated during memory distillation to record user preferences, tendencies, and work style.
 - `~/.relic/hooks/` and `~/.relic/gemini-system-default.md` are created later on first shell launch when hook registration or Gemini prompt caching is needed.
 
 ## Sample Engrams
 
-`relic init` seeds two ready-to-use Engrams:
+`relic init` seeds two ready-to-use Engrams. Their SOUL.md and IDENTITY.md follow the [OpenClaw](https://github.com/openclaw/openclaw) format.
+
+> **Existing users:** The latest templates are always available in [`templates/engrams/`](templates/engrams/). Copy them over your `~/.relic/engrams/` files to update.
 
 ### Johnny Silverhand (`johnny`)
 
@@ -118,40 +140,42 @@ relic claude --engram motoko
        |                   |                    |
        |             compose & inject           |
        |                   v                    v
-       |              +---------+          +---------+
-       +--------------| Engram  |--------->|Construct|
-                      |(persona)|          | (live)  |
-                      +---------+          +---------+
-                      SOUL.md              claude / codex / gemini
-                      IDENTITY.md               |
-                      MEMORY.md                 | hooks append logs
-                      memory/*.md               v
-                                          +-----------+
-                                          |archive.md |
-                                          | raw logs  |
-                                          +-----------+
-                                                |
-                           MCP recall           | user-triggered
-                          search/pending        | distillation
-                                                v
-                                          +-----------+
-                                          | distilled |
-                                          |memory/*.md|
-                                          +-----------+
-                                                |
-                                           promote key
-                                             insights
-                                                v
-                                             MEMORY.md
+       |            ╔═══════════╗          +---------+
+       +------------║  Engram   ║--------->|Construct|
+       |            ║ (persona) ║          | (live)  |
+       |            ╚═══════════╝          +---------+
+       |            SOUL.md              claude / codex / gemini
+       |            IDENTITY.md               |
+       |            USER.md                   | hooks append logs
+       |            MEMORY.md                 |
+       |            memory/*.md               v
+       |                                +-----------+
+  inject /                              |archive.md |
+ extract /                              | raw logs  |
+    sync                                +-----------+
+       |                                      |
+       v                     MCP recall       | user-triggered
+ +-----------+              search/pending    | distillation
+ |  OpenClaw |                                v
+ |  & Claws  |                          +-----------+
+ +-----------+                          | distilled |
+                                        |memory/*.md|
+                                        +-----------+
+                                              |
+                                         promote key
+                                           insights
+                                              v
+                                       MEMORY.md / USER.md
 ```
 
-1. **Engram** — A persona defined as a set of Markdown files (OpenClaw workspace-compatible)
+1. **Engram** — A persona defined as a set of Markdown files (OpenClaw workspace-compatible). The central data that everything else revolves around.
 2. **Relic** — Reads the Engram, composes it into a prompt, and injects it into...
 3. **Shell** — Any AI coding CLI. The persona takes over the session.
 4. **Construct** — A live process where an Engram is loaded into a Shell. The running instance of a persona.
 5. **archive.md** — Raw conversation logs appended automatically by background hooks after each turn.
-6. **Memory Distillation** — The user triggers distillation; the Construct recalls pending archive entries via MCP, writes distilled insights to `memory/*.md`, and can promote especially important facts into `MEMORY.md`.
-7. **Mikoshi** — Cloud backend where the full Engram is stored and synced, including persona files plus distilled memory (planned).
+6. **Memory Distillation** — The user triggers distillation; the Construct recalls pending archive entries via MCP, writes distilled insights to `memory/*.md`, and can promote especially important facts to `MEMORY.md` or update user preferences in `USER.md`.
+7. **OpenClaw & Claws** — Engrams can be injected into, extracted from, and synced with OpenClaw and other Claw-based agent frameworks via `relic claw`.
+8. **Mikoshi** — Cloud backend where the full Engram is stored and synced, including persona files plus distilled memory (planned).
 
 ## Supported Shells
 
@@ -177,8 +201,8 @@ The following hooks are used for each shell:
 | Shell | Hook |
 |-------|------|
 | [Claude Code](https://github.com/anthropics/claude-code) | Stop hook |
-| [Gemini CLI](https://github.com/google-gemini/gemini-cli) | AfterAgent hook |
 | [Codex CLI](https://github.com/openai/codex) | Stop hook |
+| [Gemini CLI](https://github.com/google-gemini/gemini-cli) | AfterAgent hook |
 
 #### Claude Code
 
@@ -208,7 +232,6 @@ On the **first run** of `relic gemini`, two one-time setups happen automatically
 
 The Engram persona is then appended to the cached default prompt and injected via `GEMINI_SYSTEM_MD` on every launch.
 
-
 ## MCP Server
 
 Relic's [MCP](https://modelcontextprotocol.io/) server is paired with CLI injection to handle memory recall.
@@ -220,9 +243,9 @@ Session logs and memory entries are written automatically by a **background hook
 |------|-------------|
 | `relic_archive_search` | Search the Engram's raw archive by keyword (newest-first) |
 | `relic_archive_pending` | Get un-distilled archive entries since the last distillation (up to 30) |
-| `relic_memory_write` | Write distilled memory to `memory/*.md`, optionally append to `MEMORY.md`, and advance the archive cursor |
+| `relic_memory_write` | Write distilled memory to `memory/*.md`, optionally append to `MEMORY.md`, optionally update `USER.md`, and advance the archive cursor |
 
-Session logs are written automatically by background hooks (Stop hook for Claude Code and Codex CLI, AfterAgent hook for Gemini CLI). Memory distillation is triggered by the user — ask the Construct to "organize memories" and it will fetch pending entries, distill key insights, and write them to `memory/*.md`. Especially important facts can be promoted to `MEMORY.md` (long-term memory included in every session) via the `long_term` parameter.
+Session logs are written automatically by background hooks (Stop hook for Claude Code and Codex CLI, AfterAgent hook for Gemini CLI). Memory distillation is triggered by the user — ask the Construct to "organize memories" and it will fetch pending entries, distill key insights, and write them to `memory/*.md`. Especially important facts can be promoted to `MEMORY.md` (long-term memory included in every session) via the `long_term` parameter. User tendencies and preferences can be updated in `USER.md` via the `user_profile` parameter.
 
 ### Setup
 
@@ -255,6 +278,21 @@ To suppress confirmation dialogs and auto-approve Relic tools across all project
 codex mcp add relic -- relic-mcp
 ```
 
+To suppress confirmation dialogs and auto-approve Relic tools, add the following to `~/.codex/config.toml`:
+
+```toml
+[mcp_servers.relic.tools.relic_archive_search]
+approval_mode = "approve"
+
+[mcp_servers.relic.tools.relic_archive_pending]
+approval_mode = "approve"
+
+[mcp_servers.relic.tools.relic_memory_write]
+approval_mode = "approve"
+```
+
+> **Note:** `trust_level = "trusted"` in `[projects."..."]` does **not** cover MCP tool approvals. Per-tool `approval_mode` is the only reliable way to auto-approve MCP tools in Codex CLI.
+
 #### Gemini CLI
 
 Add to `~/.gemini/settings.json`:
@@ -272,83 +310,82 @@ Add to `~/.gemini/settings.json`:
 
 > **Note:** `trust: true` is required to suppress confirmation dialogs for Relic tools. Without it, dialogs will appear on every call even if you select "Allow for all future sessions" — this is a known bug in Gemini CLI where the tool name is saved in the wrong format, causing the saved rule to never match.
 
-## OpenClaw Integration
+## Claw Integration
+
+Relic Engrams are natively compatible with [OpenClaw](https://github.com/openclaw/openclaw) workspaces — their file structure maps 1:1 (SOUL.md, IDENTITY.md, memory/, etc.). For other Claw-derived frameworks (Nanobot, gitagent, etc.) that fold identity into SOUL.md, the `--merge-identity` flag merges IDENTITY.md into SOUL.md on inject. Combined with `--dir`, Relic can target any Claw-compatible workspace.
 
-Relic Engrams are fully compatible with [OpenClaw](https://github.com/openclaw/openclaw) workspaces. They are mapped using a simple convention: Agent Name = Engram ID.
+Agent Name = Engram ID. All Claw commands live under `relic claw`:
 
-### Inject — Push an Engram into OpenClaw
+### Inject — Push an Engram into a Claw workspace
 
-Injects persona files (SOUL.md, IDENTITY.md, etc.) into `agents/<engramId>/agent/`. Memory entries are **not** injected — they are managed by OpenClaw independently.
+Injects persona files (SOUL.md, IDENTITY.md) into the agent's workspace directory, then automatically runs a sync for that pair. USER.md and memory are handled by the auto-sync (bidirectional merge, not overwrite). AGENTS.md and HEARTBEAT.md are left to the Claw agent.
 
-> **Note:** The OpenClaw agent must already exist. Inject writes persona files into an existing agent directory — it does not create new agents. Create the agent in OpenClaw first, then inject.
+> **Note:** The Claw agent must already exist (e.g. `openclaw agents add <name>`). Inject writes persona files into an existing workspace — it does not create new agents.
 
 ```bash
-# Inject Engram "motoko" → agents/motoko/agent/
-relic inject --engram motoko
+# Inject Engram "motoko" → workspace-motoko/
+relic claw inject --engram motoko
 
-# Inject into a differently-named agent (one-way copy)
-relic inject --engram motoko --to main
-# → agents/main/agent/ receives motoko's persona
-# → extract will create Engram "main", not "motoko"
+# Inject into a differently-named agent
+relic claw inject --engram motoko --to main
+# → workspace/ receives motoko's persona
 
-# Override OpenClaw directory (or configure once with: relic config openclaw-path)
-relic inject --engram motoko --openclaw /path/to/.openclaw
+# Override Claw directory (or configure once with: relic config claw-path)
+relic claw inject --engram motoko --dir /path/to/.fooclaw
+
+# Non-OpenClaw frameworks: merge IDENTITY.md into SOUL.md
+relic claw inject --engram motoko --dir ~/.nanobot --merge-identity
 ```
 
-### Extract — Sync memory from OpenClaw
+### Extract — Import a Claw agent as a new Engram
 
-Reads from `agents/<engramId>/agent/` and merges memory entries back to the Relic Engram.
+Creates a new Engram from an existing Claw agent workspace. This is a **one-time initial import** — if the Engram already exists, use `relic claw inject` to push updates.
 
 ```bash
-# Extract memory from agent "motoko" → merge into Engram "motoko"
-relic extract --engram motoko
+# Extract from the default (main) agent
+relic claw extract
 
-# New agent with no existing Engram (--name required)
-relic extract --engram analyst --name "Data Analyst"
+# Extract from a named agent
+relic claw extract --agent johnny
 
-# Overwrite persona files (memory is always merged)
-relic extract --engram motoko --force
+# Set a custom display name
+relic claw extract --agent analyst --name "Data Analyst"
 
-# Override OpenClaw directory (or configure once with: relic config openclaw-path)
-relic extract --engram motoko --openclaw /path/to/.openclaw
+# Override Claw directory
+relic claw extract --agent johnny --dir /path/to/.fooclaw
 ```
 
-### Sync — Watch and auto-sync
+### Sync — Bidirectional merge
 
-Watches all agents under `~/.openclaw/agents/` and automatically syncs:
+Merges `memory/*.md`, `MEMORY.md`, and `USER.md` between matching Engram/agent pairs. Only pairs where both the Engram and agent exist are synced. Also runs automatically after `inject` (skip with `--no-sync`).
 
 ```bash
-# Start watching (Ctrl+C to stop)
-relic sync
+# Sync all matching pairs
+relic claw sync
 
-# Specify a custom OpenClaw directory
-relic sync --openclaw /path/to/.openclaw
+# Override Claw directory
+relic claw sync --dir /path/to/.fooclaw
 ```
 
-On startup:
-1. Injects persona files for all agents that have a matching Engram
-2. Extracts memory entries from all agents
-
-While running:
-- Watches each agent's `memory/` directory for changes
-- Automatically merges new memory entries into the corresponding Engram
+Merge rules:
+- Files only on one side → copied to the other
+- Same content → skipped
+- Different content → merged (deduplicated) and written to both sides
 
-### Memory Sync Behavior
+### Command Summary
 
-| Scenario | Persona (SOUL, IDENTITY...) | Memory entries |
-|----------|---------------------------|----------------|
-| **inject** | Relic → OpenClaw (overwrite) | Not copied (OpenClaw manages its own) |
-| **extract** (existing Engram) | Not touched | OpenClaw → Relic (append) |
-| **extract** + `--force` | OpenClaw → Relic (overwrite) | OpenClaw → Relic (append) |
-| **extract** (new Engram) | Created from OpenClaw | Created from OpenClaw |
-| **sync** (startup) | inject for matching Engrams | extract all |
-| **sync** (watching) | — | Auto-extract on change |
+| Command | Direction | Description |
+|---------|-----------|-------------|
+| `relic claw inject -e <id>` | Relic → Claw | Push persona + auto-sync (`--no-sync` to skip, `--merge-identity` for non-OpenClaw) |
+| `relic claw extract -a <name>` | Claw → Relic | One-time import (new Engrams only) |
+| `relic claw sync` | Relic ↔ Claw | Bidirectional merge (memory, MEMORY.md, USER.md) |
 
 ## Memory Management
 
 Relic uses a **sliding window** for memory entries (default: 2 days), matching OpenClaw's approach:
 
-- `MEMORY.md` — Always included in the prompt (curated long-term memory)
+- `MEMORY.md` — Always included in the prompt (curated long-term memory — objective facts and rules)
+- `USER.md` — Always included in the prompt (user profile — preferences, tendencies, work style)
 - `memory/today.md` + `memory/yesterday.md` — Always included (configurable window)
 - Older entries — **Not included in the prompt**, but searchable via MCP
 
@@ -374,9 +411,9 @@ relic config show
 relic config default-engram           # get
 relic config default-engram johnny    # set
 
-# OpenClaw directory — used by inject/extract/sync when --openclaw is omitted
-relic config openclaw-path            # get
-relic config openclaw-path ~/.openclaw  # set
+# Claw directory — used by claw inject/extract/sync when --dir is omitted
+relic config claw-path                # get
+relic config claw-path ~/.openclaw    # set
 
 # Memory window — number of recent memory entries included in the prompt
 relic config memory-window            # get (default: 2)
@@ -389,7 +426,7 @@ relic config memory-window 5          # set
 {
   "engramsPath": "/home/user/.relic/engrams",
   "defaultEngram": "johnny",
-  "openclawPath": "/home/user/.openclaw",
+  "clawPath": "/home/user/.openclaw",
   "memoryWindowSize": 2
 }
 ```
@@ -425,23 +462,45 @@ Create a directory under `~/.relic/engrams/` with the following structure:
 }
 ```
 
-**SOUL.md** — The most important file. Defines how the persona behaves:
+**SOUL.md** — The most important file. Defines how the persona behaves. Follows the [OpenClaw](https://github.com/openclaw/openclaw) format:
 ```markdown
-You are a pragmatic systems architect who values simplicity above all.
-Never over-engineer. Always ask "what's the simplest thing that works?"
+# SOUL.md - Who You Are
+
+_You're a pragmatic systems architect who values simplicity above all._
+
+## Core Truths
+
+**Never over-engineer.** Always ask "what's the simplest thing that works?"
+
+**Be resourceful before asking.** Read the file. Check the context. Come back with answers, not questions.
+
+## Boundaries
+
+- Never add complexity without justification.
+
+## Vibe
+
+Calm, thoughtful, occasionally playful.
+
+## Continuity
+
+Each session, you wake up fresh. These files _are_ your memory. Read them. Update them. They're how you persist.
 ```
 
 **IDENTITY.md** — Defines who the persona is:
 ```markdown
-# Identity
+# IDENTITY.md - Who Am I?
 
-- Name: Alex
-- Tone: Calm, thoughtful, occasionally playful
-- Background: 20 years of distributed systems experience
-- Creed: "Boring technology wins."
+- **Name:** Alex
+- **Creature:** A pragmatic ghost in the codebase
+- **Vibe:** Calm, thoughtful, occasionally playful
+- **Emoji:** 🧱
+- **Avatar:**
 ```
 
-After creating the directory, set it as default:
+See [`templates/engrams/`](templates/engrams/) for full working examples.
+
+After creating the directory, set it as your default Engram:
 ```bash
 relic config default-engram your-persona
 ```
@@ -459,11 +518,11 @@ relic config default-engram your-persona
 ## Roadmap
 
 - [x] CLI with init, list, show commands
-- [x] Shell injection: Claude Code, Gemini CLI, Codex CLI
+- [x] Shell injection: Claude Code, Codex CLI, Gemini CLI
 - [x] MCP Server interface
-- [x] OpenClaw integration (inject / extract)
-- [x] `relic sync` — watch OpenClaw agents and auto-sync (`--cloud` for Mikoshi: planned)
-- [x] `relic config` — manage default Engram, OpenClaw path, memory window
+- [x] Claw integration (inject / extract / sync)
+- [x] `relic claw sync` — bidirectional memory sync with Claw workspaces
+- [x] `relic config` — manage default Engram, Claw path, memory window
 - [ ] `relic login` — authenticate with Mikoshi (OAuth Device Flow)
 - [ ] `relic push` / `relic pull` — sync Engrams with Mikoshi
 - [ ] Mikoshi cloud backend (`mikoshi.ectplsm.com`)

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

@@ -4,35 +4,20 @@ export interface ExtractResult {
     engramName: string;
     sourcePath: string;
     filesRead: string[];
-    memoryMerged: boolean;
 }
 /**
- * Extract — OpenClawワークスペースからEngramを作成する
+ * Extract — OpenClawワークスペースからEngramを新規作成する
  *
- * agent名 = Engram ID の規約に基づき、agents/<engramId>/agent/ から読み取る。
- *
- * 既存Engramがある場合:
- *   - --force なし → memoryエントリのみマージ（persona部分は変更しない）
- *   - --force あり → persona部分を上書き + memoryをマージ
- * 既存Engramがない場合:
- *   - 新規作成（全ファイル含む）
+ * 初回取り込み専用。Engramが既に存在する場合はエラーを返す。
+ * Relicが真のデータソースであり、extractは初期インポートのみを担う。
  */
 export declare class Extract {
     private readonly repository;
     constructor(repository: EngramRepository);
-    execute(engramId: string, options?: {
+    execute(agentName: string, options?: {
         name?: string;
         openclawDir?: string;
-        force?: boolean;
     }): Promise<ExtractResult>;
-    /**
-     * --force時: persona上書き + memoryマージ
-     */
-    private mergeAndSave;
-    /**
-     * --forceなし時: memoryエントリのみ追記（repositoryのAPIを使用）
-     */
-    private mergeMemoryOnly;
     private readFiles;
 }
 export declare class WorkspaceNotFoundError extends Error {
@@ -41,9 +26,6 @@ export declare class WorkspaceNotFoundError extends Error {
 export declare class WorkspaceEmptyError extends Error {
     constructor(path: string);
 }
-export declare class EngramAlreadyExistsError extends Error {
-    constructor(id: string);
-}
-export declare class ExtractNameRequiredError extends Error {
+export declare class AlreadyExtractedError extends Error {
     constructor(id: string);
 }

package/dist/core/usecases/extract.js

@@ -1,69 +1,39 @@
 import { join } from "node:path";
 import { existsSync } from "node:fs";
 import { readFile, readdir } from "node:fs/promises";
-import { FILE_MAP, MEMORY_DIR, resolveAgentPath } from "../../shared/openclaw.js";
+import { RELIC_FILE_MAP, MEMORY_DIR, resolveWorkspacePath } from "../../shared/openclaw.js";
 /**
- * Extract — OpenClawワークスペースからEngramを作成する
+ * Extract — OpenClawワークスペースからEngramを新規作成する
  *
- * agent名 = Engram ID の規約に基づき、agents/<engramId>/agent/ から読み取る。
- *
- * 既存Engramがある場合:
- *   - --force なし → memoryエントリのみマージ（persona部分は変更しない）
- *   - --force あり → persona部分を上書き + memoryをマージ
- * 既存Engramがない場合:
- *   - 新規作成（全ファイル含む）
+ * 初回取り込み専用。Engramが既に存在する場合はエラーを返す。
+ * Relicが真のデータソースであり、extractは初期インポートのみを担う。
  */
 export class Extract {
     repository;
     constructor(repository) {
         this.repository = repository;
     }
-    async execute(engramId, options) {
-        const sourcePath = resolveAgentPath(engramId, options?.openclawDir);
+    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) {
+            throw new AlreadyExtractedError(agentName);
+        }
         const { files, filesRead } = await this.readFiles(sourcePath);
         if (filesRead.length === 0) {
             throw new WorkspaceEmptyError(sourcePath);
         }
-        const existing = await this.repository.get(engramId);
-        if (existing) {
-            if (options?.force) {
-                // --force: persona上書き + memoryマージ
-                const merged = await this.mergeAndSave(existing, files, options.name ?? existing.meta.name);
-                return {
-                    engramId,
-                    engramName: options.name ?? existing.meta.name,
-                    sourcePath,
-                    filesRead,
-                    memoryMerged: merged,
-                };
-            }
-            // --forceなし: memoryのみマージ
-            if (!files.memoryEntries || Object.keys(files.memoryEntries).length === 0) {
-                throw new EngramAlreadyExistsError(engramId);
-            }
-            const merged = await this.mergeMemoryOnly(engramId, files.memoryEntries);
-            return {
-                engramId,
-                engramName: existing.meta.name,
-                sourcePath,
-                filesRead,
-                memoryMerged: merged,
-            };
-        }
-        // 新規作成 — nameは必須
-        const engramName = options?.name;
-        if (!engramName) {
-            throw new ExtractNameRequiredError(engramId);
-        }
+        const engramName = options?.name ?? agentName;
         const now = new Date().toISOString();
         const engram = {
             meta: {
-                id: engramId,
+                id: agentName,
                 name: engramName,
-                description: `Extracted from OpenClaw agent (${engramId})`,
+                description: `Extracted from OpenClaw workspace (${agentName})`,
                 createdAt: now,
                 updatedAt: now,
                 tags: ["extracted", "openclaw"],
@@ -72,76 +42,16 @@ export class Extract {
         };
         await this.repository.save(engram);
         return {
-            engramId,
+            engramId: agentName,
             engramName,
             sourcePath,
             filesRead,
-            memoryMerged: false,
         };
     }
-    /**
-     * --force時: persona上書き + memoryマージ
-     */
-    async mergeAndSave(existing, newFiles, engramName) {
-        const mergedFiles = { ...newFiles };
-        // memoryEntriesをマージ
-        let memoryMerged = false;
-        if (newFiles.memoryEntries) {
-            mergedFiles.memoryEntries = { ...existing.files.memoryEntries };
-            for (const [date, content] of Object.entries(newFiles.memoryEntries)) {
-                const existingContent = mergedFiles.memoryEntries?.[date];
-                if (existingContent) {
-                    const separator = existingContent.endsWith("\n") ? "\n" : "\n\n";
-                    mergedFiles.memoryEntries[date] = existingContent + separator + content;
-                }
-                else {
-                    mergedFiles.memoryEntries = mergedFiles.memoryEntries ?? {};
-                    mergedFiles.memoryEntries[date] = content;
-                }
-                memoryMerged = true;
-            }
-        }
-        const updatedEngram = {
-            meta: {
-                ...existing.meta,
-                name: engramName,
-                updatedAt: new Date().toISOString(),
-            },
-            files: mergedFiles,
-        };
-        await this.repository.save(updatedEngram);
-        return memoryMerged;
-    }
-    /**
-     * --forceなし時: memoryエントリのみ追記（repositoryのAPIを使用）
-     */
-    async mergeMemoryOnly(engramId, newEntries) {
-        const existing = await this.repository.get(engramId);
-        if (!existing)
-            return false;
-        const mergedEntries = { ...existing.files.memoryEntries };
-        for (const [date, content] of Object.entries(newEntries)) {
-            const existingContent = mergedEntries[date];
-            if (existingContent) {
-                const separator = existingContent.endsWith("\n") ? "\n" : "\n\n";
-                mergedEntries[date] = existingContent + separator + content;
-            }
-            else {
-                mergedEntries[date] = content;
-            }
-        }
-        const updatedEngram = {
-            ...existing,
-            meta: { ...existing.meta, updatedAt: new Date().toISOString() },
-            files: { ...existing.files, memoryEntries: mergedEntries },
-        };
-        await this.repository.save(updatedEngram);
-        return true;
-    }
     async readFiles(sourcePath) {
         const files = {};
         const filesRead = [];
-        for (const [key, filename] of Object.entries(FILE_MAP)) {
+        for (const [key, filename] of Object.entries(RELIC_FILE_MAP)) {
             const filePath = join(sourcePath, filename);
             if (existsSync(filePath)) {
                 files[key] = await readFile(filePath, "utf-8");
@@ -176,15 +86,9 @@ export class WorkspaceEmptyError extends Error {
         this.name = "WorkspaceEmptyError";
     }
 }
-export class EngramAlreadyExistsError extends Error {
-    constructor(id) {
-        super(`Engram "${id}" already exists. Use --force to overwrite.`);
-        this.name = "EngramAlreadyExistsError";
-    }
-}
-export class ExtractNameRequiredError extends Error {
+export class AlreadyExtractedError extends Error {
     constructor(id) {
-        super(`No existing Engram "${id}" found. --name is required for new Engrams.`);
-        this.name = "ExtractNameRequiredError";
+        super(`Engram "${id}" already exists. Relic is the source of truth — use "relic claw inject" to push changes.`);
+        this.name = "AlreadyExtractedError";
     }
 }

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

@@ -1,9 +1,9 @@
 export { Summon, EngramNotFoundError, type SummonResult } from "./summon.js";
 export { ListEngrams } from "./list-engrams.js";
 export { Init, type InitResult } from "./init.js";
-export { Inject, InjectEngramNotFoundError, InjectAgentNotFoundError, type InjectResult, } from "./inject.js";
-export { Extract, WorkspaceNotFoundError, WorkspaceEmptyError, EngramAlreadyExistsError, ExtractNameRequiredError, type ExtractResult, } from "./extract.js";
+export { Inject, InjectEngramNotFoundError, InjectClawDirNotFoundError, InjectWorkspaceNotFoundError, type InjectResult, } from "./inject.js";
+export { Extract, WorkspaceNotFoundError, WorkspaceEmptyError, AlreadyExtractedError, type ExtractResult, } from "./extract.js";
 export { MemoryWrite, MemoryWriteEngramNotFoundError, type MemoryWriteResult, } from "./memory-write.js";
-export { Sync, SyncAgentsDirNotFoundError, type SyncTarget, type SyncInitialResult, } from "./sync.js";
+export { Sync, SyncOpenclawDirNotFoundError, type SyncTarget, type SyncResult, type SyncInitialResult, } from "./sync.js";
 export { ArchivePending, ArchivePendingEngramNotFoundError, type ArchivePendingResult, } from "./archive-pending.js";
 export { ArchiveCursorUpdate, ArchiveCursorUpdateEngramNotFoundError, type ArchiveCursorUpdateResult, } from "./archive-cursor-update.js";