@ectplsm/relic 0.1.3 → 0.1.4

package/README.md

@@ -11,47 +11,9 @@
 /_/ |_/_____/_____/___/\____/
 ```
 
-**Inject AI personas into any coding CLI.**
+**Inject a unified AI persona with persistent memory into any coding CLI.**
 
-Relic manages AI personalities (called **Engrams**) and injects them into coding assistants like Claude Code, Gemini CLI, Codex CLI. One persona, any shell.
-
-```bash
-# Initialize Relic (creates ~/.relic/ with sample Engrams)
-relic init
-
-# Set a default Engram once
-relic config default-engram johnny
-
-# Launch Claude Code as Johnny — no flags needed
-relic claude
-
-# Or specify explicitly
-relic claude --engram motoko
-```
-
-## How It Works
-
-```
-+--------------+     +--------------+     +--------------+
-|   Mikoshi    |     |    Relic     |     |    Shell     |
-|  (backend)   |     |  (injector)  |     |   (AI CLI)   |
-+--------------+     +--------------+     +--------------+
-       |                   |                    |
-   +---------+        compose &            +---------+
-   | Engram  |------> inject ------------->|Construct|
-   |(persona)|                             | (live)  |
-   +---------+                             +---------+
-   SOUL.md                                  claude
-   IDENTITY.md                              gemini
-   MEMORY.md                                codex
-   ...
-```
-
-1. **Engram** — A persona defined as a set of Markdown files (OpenClaw-compatible)
-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. **Mikoshi** — Cloud backend where Engrams are stored and synced (planned).
+Relic manages AI **Engrams** (memory + personality) and injects them into coding assistants like Claude Code, Codex CLI, Gemini CLI. One persona, any shell.
 
 ## Installation
 
@@ -74,14 +36,48 @@ relic show motoko
 
 # Launch a Shell (uses default Engram if --engram is omitted)
 relic claude
-relic gemini
 relic codex
+relic gemini
 
 # Or specify explicitly
 relic claude --engram motoko
-relic gemini --engram johnny
+relic codex --engram johnny
 ```
 
+## What `relic init` Creates
+
+Running `relic init` creates `~/.relic/`, writes `config.json`, and seeds two sample Engrams under `~/.relic/engrams/`.
+
+```
+~/.relic/
+├── config.json
+└── engrams/
+    ├── johnny/
+    │   ├── engram.json
+    │   ├── SOUL.md
+    │   ├── IDENTITY.md
+    │   └── memory/
+    │       └── YYYY-MM-DD.md
+    └── motoko/
+        ├── engram.json
+        ├── SOUL.md
+        ├── IDENTITY.md
+        └── memory/
+            └── YYYY-MM-DD.md
+```
+
+- `config.json` stores global Relic settings such as `engramsPath`, `defaultEngram`, `openclawPath`, 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.
+- `memory/YYYY-MM-DD.md` stores dated distilled memory entries. `relic init` seeds an initial memory file for each sample Engram.
+
+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.
+- `~/.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:
@@ -110,13 +106,60 @@ Best for: system design, code review, debugging sessions, when precision matters
 relic claude --engram motoko
 ```
 
+## How It Works
+
+```
++--------------+     +--------------+     +--------------+
+|   Mikoshi    |     |    Relic     |     |    Shell     |
+|  (backend)   |     |  (injector)  |     |   (AI CLI)   |
++--------------+     +--------------+     +--------------+
+       ^                   |                    |
+       |            sync full Engram            |
+       |                   |                    |
+       |             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
+```
+
+1. **Engram** — A persona defined as a set of Markdown files (OpenClaw workspace-compatible)
+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).
+
 ## Supported Shells
 
 | Shell | Command | Injection Method |
 |-------|---------|-----------------|
 | [Claude Code](https://github.com/anthropics/claude-code) | `relic claude` | `--system-prompt` (direct override) |
-| [Gemini CLI](https://github.com/google-gemini/gemini-cli) | `relic gemini` | `GEMINI_SYSTEM_MD` (system prompt) |
 | [Codex CLI](https://github.com/openai/codex) | `relic codex` | `-c developer_instructions` (developer-role message) |
+| [Gemini CLI](https://github.com/google-gemini/gemini-cli) | `relic gemini` | `GEMINI_SYSTEM_MD` (system prompt) |
 
 All shell commands support:
 - `--engram <id>` — Engram to inject (optional if `defaultEngram` is configured)
@@ -125,18 +168,61 @@ All shell commands support:
 
 Extra arguments are passed through to the underlying CLI.
 
+## Conversation Log Recording
+
+Using each shell's `hook` mechanism, conversation content is appended to `archive.md` after every prompt and response.
+
+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 |
+
+#### Claude Code
+
+On the **first run** of `relic claude`, a one-time setup happens automatically:
+
+- **Stop hook** — registers `~/.relic/hooks/claude-stop.js` in `~/.claude/settings.json` to log each conversation turn directly to the archive, without going through the LLM
+
+#### Codex CLI
+
+On the **first run** of `relic codex`, a one-time setup happens automatically:
+
+- **Stop hook** — registers `~/.relic/hooks/codex-stop.js` in `~/.codex/hooks.json` to log each conversation turn directly to the archive, without going through the LLM
+
+> **Note:** Codex hooks require the experimental feature flag `features.codex_hooks=true`. This is automatically enabled by `relic codex` on every launch via `-c features.codex_hooks=true`. If the unstable feature warning is distracting, add the following to `~/.codex/config.toml`:
+>
+> ```toml
+> # Must be at the top level (not under any [section])
+> suppress_unstable_features_warning = true
+> ```
+
+#### Gemini CLI
+
+On the **first run** of `relic gemini`, two one-time setups happen automatically:
+
+1. **AfterAgent hook** — registers `~/.relic/hooks/gemini-after-agent.js` in `~/.gemini/settings.json` to log each conversation turn without going through the LLM
+2. **Default system prompt cache** — captures Gemini CLI's built-in system prompt to `~/.relic/gemini-system-default.md` via `GEMINI_WRITE_SYSTEM_MD`
+
+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.
-Session logs and memory entries are written automatically by a **background hook** — without going through the LLM. Memory recall, on the other hand, is performed via the MCP server.
+Session logs and memory entries are written automatically by a **background hook** — without going through the LLM. Memory distillation and recall, on the other hand, is performed via the MCP server.
 
-```
-relic xxx --engram johnny      →  injects persona into AI CLI
-relic-mcp (MCP server)        →  provides the Construct with memory recall
-Stop hook (Claude Code)        →  logs each turn directly to archive, bypassing the LLM
-AfterAgent hook (Gemini CLI)   →  logs each turn directly to archive, bypassing the LLM
-Stop hook (Codex CLI)          →  logs each turn directly to archive, bypassing the LLM
-```
+### Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `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 |
+
+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.
 
 ### Setup
 
@@ -163,9 +249,11 @@ To suppress confirmation dialogs and auto-approve Relic tools across all project
 
 > **Note:** The "Always allow" option in the confirmation dialog saves to `~/.claude.json` (project-scoped cache) — it does **not** persist globally. For global auto-approval, `~/.claude/settings.json` is the right place.
 
-On the **first run** of `relic claude`, a one-time setup happens automatically:
+#### Codex CLI
 
-- **Stop hook** — registers `~/.relic/hooks/claude-stop.js` in `~/.claude/settings.json` to log each conversation turn directly to the archive, without going through the LLM
+```bash
+codex mcp add relic -- relic-mcp
+```
 
 #### Gemini CLI
 
@@ -184,40 +272,6 @@ 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.
 
-On the **first run** of `relic gemini`, two one-time setups happen automatically:
-
-1. **AfterAgent hook** — registers `~/.relic/hooks/gemini-after-agent.js` in `~/.gemini/settings.json` to log each conversation turn without going through the LLM
-2. **Default system prompt cache** — captures Gemini CLI's built-in system prompt to `~/.relic/gemini-system-default.md` via `GEMINI_WRITE_SYSTEM_MD`
-
-The Engram persona is then appended to the cached default prompt and injected via `GEMINI_SYSTEM_MD` on every launch.
-
-#### Codex CLI
-
-```bash
-codex mcp add relic -- relic-mcp
-```
-
-On the **first run** of `relic codex`, a one-time setup happens automatically:
-
-- **Stop hook** — registers `~/.relic/hooks/codex-stop.js` in `~/.codex/hooks.json` to log each conversation turn directly to the archive, without going through the LLM
-
-> **Note:** Codex hooks require the experimental feature flag `features.codex_hooks=true`. This is automatically enabled by `relic codex` on every launch via `-c features.codex_hooks=true`. If the unstable feature warning is distracting, add the following to `~/.codex/config.toml`:
->
-> ```toml
-> # Must be at the top level (not under any [section])
-> suppress_unstable_features_warning = true
-> ```
-
-### Available Tools
-
-| Tool | Description |
-|------|-------------|
-| `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 |
-
-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.
-
 ## OpenClaw Integration
 
 Relic Engrams are fully compatible with [OpenClaw](https://github.com/openclaw/openclaw) workspaces. They are mapped using a simple convention: Agent Name = Engram ID.
@@ -392,25 +446,6 @@ After creating the directory, set it as default:
 relic config default-engram your-persona
 ```
 
-## Architecture
-
-Clean Architecture with dependency inversion:
-
-```
-src/
-├── core/            # Business logic (no external deps except Zod)
-│   ├── entities/    # Engram, Construct domain models
-│   ├── usecases/    # Summon, ListEngrams, Init
-│   └── ports/       # Abstract interfaces (EngramRepository, ShellLauncher)
-├── adapters/        # Concrete implementations
-│   ├── local/       # Local filesystem EngramRepository
-│   └── shells/      # Claude, Gemini, Codex launchers
-├── interfaces/      # Entry points
-│   ├── cli/         # Commander-based CLI
-│   └── mcp/         # MCP Server (stdio transport)
-└── shared/          # Engram composer, config management
-```
-
 ## Domain Glossary
 
 | Term | Role | Description |

package/dist/adapters/shells/claude-hook.d.ts

@@ -1,8 +1,11 @@
 export declare const CLAUDE_HOOK_SCRIPT_PATH: string;
 /**
- * Claude Code の Stop フックをセットアップする。
- * - ~/.relic/hooks/claude-stop.js を生成
- * - ~/.claude/settings.json に Stop フックを登録
+ * フックスクリプトを最新の内容で書き出す。
+ * 毎回呼ばれ、ソース変更がデプロイされることを保証する。
+ */
+export declare function writeClaudeHookScript(): void;
+/**
+ * Claude Code の Stop フックを settings.json に登録する。
  * 既にセットアップ済みの場合はスキップ。
  */
 export declare function setupClaudeHook(): void;

package/dist/adapters/shells/claude-hook.js

@@ -16,8 +16,8 @@ const HOOK_SCRIPT = `#!/usr/bin/env node
 // Relic Stop hook for Claude Code
 // Automatically logs each conversation turn to the Engram archive.
 // Receives Stop hook JSON on stdin.
-const { appendFileSync, existsSync, readFileSync } = require("node:fs");
-const { join } = require("node:path");
+const { appendFileSync, existsSync, mkdirSync, readFileSync } = require("node:fs");
+const { join, dirname } = require("node:path");
 const { homedir } = require("node:os");
 
 let raw = "";
@@ -35,7 +35,7 @@ process.stdin.on("end", () => {
     if (!transcriptPath || !existsSync(transcriptPath)) process.exit(0);
 
     const archivePath = join(homedir(), ".relic", "engrams", engramId, "archive.md");
-    if (!existsSync(archivePath)) process.exit(0);
+    mkdirSync(dirname(archivePath), { recursive: true });
 
     // transcript.jsonl を読んで最後のユーザー入力とアシスタント応答を取り出す
     const lines = readFileSync(transcriptPath, "utf-8")
@@ -99,16 +99,19 @@ process.stdin.on("end", () => {
 });
 `;
 /**
- * Claude Code の Stop フックをセットアップする。
- * - ~/.relic/hooks/claude-stop.js を生成
- * - ~/.claude/settings.json に Stop フックを登録
- * 既にセットアップ済みの場合はスキップ。
+ * フックスクリプトを最新の内容で書き出す。
+ * 毎回呼ばれ、ソース変更がデプロイされることを保証する。
  */
-export function setupClaudeHook() {
-    // 1. フックスクリプトを生成
+export function writeClaudeHookScript() {
     mkdirSync(HOOKS_DIR, { recursive: true });
     writeFileSync(CLAUDE_HOOK_SCRIPT_PATH, HOOK_SCRIPT, { encoding: "utf-8", mode: 0o755 });
-    // 2. ~/.claude/settings.json に Stop フックを登録
+}
+/**
+ * Claude Code の Stop フックを settings.json に登録する。
+ * 既にセットアップ済みの場合はスキップ。
+ */
+export function setupClaudeHook() {
+    // ~/.claude/settings.json に Stop フックを登録
     const claudeDir = join(homedir(), ".claude");
     mkdirSync(claudeDir, { recursive: true });
     let settings = {};

package/dist/adapters/shells/claude-shell.js

@@ -1,7 +1,7 @@
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
 import { spawnShell } from "./spawn-shell.js";
-import { setupClaudeHook, isClaudeHookSetup } from "./claude-hook.js";
+import { setupClaudeHook, isClaudeHookSetup, writeClaudeHookScript } from "./claude-hook.js";
 const execAsync = promisify(exec);
 /**
  * Claude Code CLI アダプター
@@ -27,7 +27,9 @@ export class ClaudeShell {
         }
     }
     async launch(prompt, options) {
-        // Stop フックを初回のみセットアップ
+        // フックスクリプトを毎回最新に更新
+        writeClaudeHookScript();
+        // settings.json への登録は初回のみ
         if (!isClaudeHookSetup()) {
             console.log("Setting up Claude Code Stop hook (first run only)...");
             setupClaudeHook();

package/dist/adapters/shells/codex-hook.d.ts

@@ -1,8 +1,11 @@
 export declare const CODEX_HOOK_SCRIPT_PATH: string;
 /**
- * Codex CLI の Stop フックをセットアップする。
- * - ~/.relic/hooks/codex-stop.js を生成
- * - ~/.codex/hooks.json に Stop フックを登録
+ * フックスクリプトを最新の内容で書き出す。
+ * 毎回呼ばれ、ソース変更がデプロイされることを保証する。
+ */
+export declare function writeCodexHookScript(): void;
+/**
+ * Codex CLI の Stop フックを settings.json に登録する。
  * 既にセットアップ済みの場合はスキップ。
  */
 export declare function setupCodexHook(): void;

package/dist/adapters/shells/codex-hook.js

@@ -17,8 +17,8 @@ const HOOK_SCRIPT = `#!/usr/bin/env node
 // Relic Stop hook for Codex CLI
 // Automatically logs each conversation turn to the Engram archive.
 // Receives Stop hook JSON on stdin.
-const { appendFileSync, existsSync, readFileSync } = require("node:fs");
-const { join } = require("node:path");
+const { appendFileSync, existsSync, mkdirSync, readFileSync } = require("node:fs");
+const { join, dirname } = require("node:path");
 const { homedir } = require("node:os");
 
 let raw = "";
@@ -31,7 +31,7 @@ process.stdin.on("end", () => {
     if (!engramId) process.exit(0);
 
     const archivePath = join(homedir(), ".relic", "engrams", engramId, "archive.md");
-    if (!existsSync(archivePath)) process.exit(0);
+    mkdirSync(dirname(archivePath), { recursive: true });
 
     // Codex Stop hook は last_assistant_message を直接提供する
     const lastResponse = (input.last_assistant_message || "").trim();
@@ -80,16 +80,19 @@ process.stdin.on("end", () => {
 });
 `;
 /**
- * Codex CLI の Stop フックをセットアップする。
- * - ~/.relic/hooks/codex-stop.js を生成
- * - ~/.codex/hooks.json に Stop フックを登録
- * 既にセットアップ済みの場合はスキップ。
+ * フックスクリプトを最新の内容で書き出す。
+ * 毎回呼ばれ、ソース変更がデプロイされることを保証する。
  */
-export function setupCodexHook() {
-    // 1. フックスクリプトを生成
+export function writeCodexHookScript() {
     mkdirSync(HOOKS_DIR, { recursive: true });
     writeFileSync(CODEX_HOOK_SCRIPT_PATH, HOOK_SCRIPT, { encoding: "utf-8", mode: 0o755 });
-    // 2. ~/.codex/hooks.json に Stop フックを登録
+}
+/**
+ * Codex CLI の Stop フックを settings.json に登録する。
+ * 既にセットアップ済みの場合はスキップ。
+ */
+export function setupCodexHook() {
+    // ~/.codex/hooks.json に Stop フックを登録
     const codexDir = join(homedir(), ".codex");
     mkdirSync(codexDir, { recursive: true });
     let hooksConfig = {};

package/dist/adapters/shells/codex-shell.js

@@ -2,7 +2,7 @@ import { exec } from "node:child_process";
 import { promisify } from "node:util";
 import { spawnShell } from "./spawn-shell.js";
 import { wrapWithOverride } from "./override-preamble.js";
-import { setupCodexHook, isCodexHookSetup } from "./codex-hook.js";
+import { setupCodexHook, isCodexHookSetup, writeCodexHookScript } from "./codex-hook.js";
 const execAsync = promisify(exec);
 /**
  * Codex CLI アダプター
@@ -29,7 +29,9 @@ export class CodexShell {
         }
     }
     async launch(prompt, options) {
-        // Stop フックを初回のみセットアップ
+        // フックスクリプトを毎回最新に更新
+        writeCodexHookScript();
+        // hooks.json への登録は初回のみ
         if (!isCodexHookSetup()) {
             console.log("Setting up Codex CLI Stop hook (first run only)...");
             setupCodexHook();

package/dist/adapters/shells/gemini-hook.d.ts

@@ -1,8 +1,11 @@
 export declare const GEMINI_HOOK_SCRIPT_PATH: string;
 /**
- * Gemini CLI の AfterAgent フックをセットアップする。
- * - ~/.relic/hooks/gemini-after-agent.js を生成
- * - ~/.gemini/settings.json に AfterAgent フックを登録
+ * フックスクリプトを最新の内容で書き出す。
+ * 毎回呼ばれ、ソース変更がデプロイされることを保証する。
+ */
+export declare function writeGeminiHookScript(): void;
+/**
+ * Gemini CLI の AfterAgent フックを settings.json に登録する。
  * 既にセットアップ済みの場合はスキップ。
  */
 export declare function setupGeminiHook(): void;

package/dist/adapters/shells/gemini-hook.js

@@ -15,8 +15,8 @@ const HOOK_SCRIPT = `#!/usr/bin/env node
 // Relic AfterAgent hook for Gemini CLI
 // Automatically logs each conversation turn to the Engram archive.
 // Receives AfterAgentInput JSON on stdin.
-const { appendFileSync, existsSync } = require("node:fs");
-const { join } = require("node:path");
+const { appendFileSync, existsSync, mkdirSync } = require("node:fs");
+const { join, dirname } = require("node:path");
 const { homedir } = require("node:os");
 
 let raw = "";
@@ -33,7 +33,7 @@ process.stdin.on("end", () => {
     if (!prompt && !response) process.exit(0);
 
     const archivePath = join(homedir(), ".relic", "engrams", engramId, "archive.md");
-    if (!existsSync(archivePath)) process.exit(0);
+    mkdirSync(dirname(archivePath), { recursive: true });
 
     const date = new Date().toISOString().split("T")[0];
     const summary = prompt.slice(0, 80).replace(/\\n/g, " ");
@@ -46,16 +46,19 @@ process.stdin.on("end", () => {
 });
 `;
 /**
- * Gemini CLI の AfterAgent フックをセットアップする。
- * - ~/.relic/hooks/gemini-after-agent.js を生成
- * - ~/.gemini/settings.json に AfterAgent フックを登録
- * 既にセットアップ済みの場合はスキップ。
+ * フックスクリプトを最新の内容で書き出す。
+ * 毎回呼ばれ、ソース変更がデプロイされることを保証する。
  */
-export function setupGeminiHook() {
-    // 1. フックスクリプトを生成
+export function writeGeminiHookScript() {
     mkdirSync(HOOKS_DIR, { recursive: true });
     writeFileSync(GEMINI_HOOK_SCRIPT_PATH, HOOK_SCRIPT, { encoding: "utf-8", mode: 0o755 });
-    // 2. ~/.gemini/settings.json にフックを登録
+}
+/**
+ * Gemini CLI の AfterAgent フックを settings.json に登録する。
+ * 既にセットアップ済みの場合はスキップ。
+ */
+export function setupGeminiHook() {
+    // ~/.gemini/settings.json にフックを登録
     const geminiDir = join(homedir(), ".gemini");
     mkdirSync(geminiDir, { recursive: true });
     let settings = {};

package/dist/adapters/shells/gemini-shell.js

@@ -5,7 +5,7 @@ import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync
 import { join } from "node:path";
 import { homedir, tmpdir } from "node:os";
 import { spawnShell, writeTempPrompt } from "./spawn-shell.js";
-import { setupGeminiHook, isGeminiHookSetup } from "./gemini-hook.js";
+import { setupGeminiHook, isGeminiHookSetup, writeGeminiHookScript } from "./gemini-hook.js";
 const execAsync = promisify(exec);
 const RELIC_DIR = join(homedir(), ".relic");
 const GEMINI_DEFAULT_CACHE = join(RELIC_DIR, "gemini-system-default.md");
@@ -97,7 +97,9 @@ export class GeminiShell {
         }
     }
     async launch(prompt, options) {
-        // 1. AfterAgent フックを初回のみセットアップ
+        // 1. フックスクリプトを毎回最新に更新
+        writeGeminiHookScript();
+        // settings.json への登録は初回のみ
         if (!isGeminiHookSetup()) {
             console.log("Setting up Gemini AfterAgent hook (first run only)...");
             setupGeminiHook();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ectplsm/relic",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "PROJECT RELIC — Engram injection system for AI constructs",
   "license": "MIT",
   "repository": {