@ectplsm/relic 0.1.2 → 0.1.4

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

@@ -1,10 +1,14 @@
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
 import { spawnShell } from "./spawn-shell.js";
+import { setupClaudeHook, isClaudeHookSetup, writeClaudeHookScript } from "./claude-hook.js";
 const execAsync = promisify(exec);
 /**
  * Claude Code CLI アダプター
  * --system-prompt フラグでEngramを直接注入する。
+ *
+ * 初回起動時に Stop フックを ~/.claude/settings.json に登録し、
+ * 各ターン終了後に会話ログを Engram archive に自動記録する。
  */
 export class ClaudeShell {
     command;
@@ -22,12 +26,24 @@ export class ClaudeShell {
             return false;
         }
     }
-    async launch(prompt, extraArgs = [], cwd) {
+    async launch(prompt, options) {
+        // フックスクリプトを毎回最新に更新
+        writeClaudeHookScript();
+        // settings.json への登録は初回のみ
+        if (!isClaudeHookSetup()) {
+            console.log("Setting up Claude Code Stop hook (first run only)...");
+            setupClaudeHook();
+            console.log("Hook registered to ~/.claude/settings.json");
+            console.log();
+        }
         const args = [
             "--system-prompt",
             prompt,
-            ...extraArgs,
+            ...(options?.extraArgs ?? []),
         ];
-        await spawnShell(this.command, args, cwd);
+        const env = {};
+        if (options?.engramId)
+            env.RELIC_ENGRAM_ID = options.engramId;
+        await spawnShell(this.command, args, options?.cwd, Object.keys(env).length > 0 ? env : undefined);
     }
 }

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

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

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

@@ -0,0 +1,144 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+const RELIC_DIR = join(homedir(), ".relic");
+const HOOKS_DIR = join(RELIC_DIR, "hooks");
+export const CODEX_HOOK_SCRIPT_PATH = join(HOOKS_DIR, "codex-stop.js");
+const CODEX_HOOKS_PATH = join(homedir(), ".codex", "hooks.json");
+const RELIC_HOOK_COMMAND = `node ${join(HOOKS_DIR, "codex-stop.js")}`;
+/**
+ * Stop hook スクリプトの内容。
+ * Codex CLI の各ターン終了後に発火し、会話ログを Engram archive に追記する。
+ * RELIC_ENGRAM_ID 環境変数で対象 Engram ID を受け取る。
+ * stdin には { last_assistant_message, transcript_path, session_id, ... } が渡される。
+ * Claude の Stop hook と異なり last_assistant_message が直接取得できるため wait 不要。
+ */
+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, mkdirSync, readFileSync } = require("node:fs");
+const { join, dirname } = require("node:path");
+const { homedir } = require("node:os");
+
+let raw = "";
+process.stdin.setEncoding("utf-8");
+process.stdin.on("data", (chunk) => { raw += chunk; });
+process.stdin.on("end", () => {
+  try {
+    const input = JSON.parse(raw);
+    const engramId = process.env.RELIC_ENGRAM_ID;
+    if (!engramId) process.exit(0);
+
+    const archivePath = join(homedir(), ".relic", "engrams", engramId, "archive.md");
+    mkdirSync(dirname(archivePath), { recursive: true });
+
+    // Codex Stop hook は last_assistant_message を直接提供する
+    const lastResponse = (input.last_assistant_message || "").trim();
+
+    // transcript から最後のユーザー入力を取得
+    // Codex transcript format:
+    //   { type: "response_item", payload: { type: "message", role: "user", content: [{ type: "input_text", text: "..." }] } }
+    // <environment_context> で始まるエントリはシステム注入なのでスキップする
+    let lastPrompt = "";
+    const transcriptPath = input.transcript_path;
+    if (transcriptPath && existsSync(transcriptPath)) {
+      const lines = readFileSync(transcriptPath, "utf-8")
+        .split("\\n")
+        .filter(Boolean)
+        .map((l) => { try { return JSON.parse(l); } catch { return null; } })
+        .filter(Boolean);
+
+      for (let i = lines.length - 1; i >= 0; i--) {
+        const entry = lines[i];
+        if (entry.type !== "response_item") continue;
+        const p = entry.payload;
+        if (!p || p.role !== "user" || p.type !== "message") continue;
+        const content = p.content;
+        if (Array.isArray(content)) {
+          const texts = content
+            .filter((c) => c.type === "input_text" && c.text && !c.text.trimStart().startsWith("<environment_context>"))
+            .map((c) => c.text.trim());
+          if (texts.length > 0) {
+            lastPrompt = texts.join("\\n").trim();
+            break;
+          }
+        }
+      }
+    }
+
+    if (!lastPrompt && !lastResponse) process.exit(0);
+
+    const date = new Date().toISOString().split("T")[0];
+    const summary = lastPrompt.slice(0, 80).replace(/\\n/g, " ");
+    const entry = \`\\n---\\n\${date} | \${summary}\\n\${lastResponse}\\n\`;
+    appendFileSync(archivePath, entry, "utf-8");
+  } catch {
+    // silently ignore
+  }
+  process.exit(0);
+});
+`;
+/**
+ * フックスクリプトを最新の内容で書き出す。
+ * 毎回呼ばれ、ソース変更がデプロイされることを保証する。
+ */
+export function writeCodexHookScript() {
+    mkdirSync(HOOKS_DIR, { recursive: true });
+    writeFileSync(CODEX_HOOK_SCRIPT_PATH, HOOK_SCRIPT, { encoding: "utf-8", mode: 0o755 });
+}
+/**
+ * Codex CLI の Stop フックを settings.json に登録する。
+ * 既にセットアップ済みの場合はスキップ。
+ */
+export function setupCodexHook() {
+    // ~/.codex/hooks.json に Stop フックを登録
+    const codexDir = join(homedir(), ".codex");
+    mkdirSync(codexDir, { recursive: true });
+    let hooksConfig = {};
+    if (existsSync(CODEX_HOOKS_PATH)) {
+        try {
+            hooksConfig = JSON.parse(readFileSync(CODEX_HOOKS_PATH, "utf-8"));
+        }
+        catch {
+            hooksConfig = {};
+        }
+    }
+    const hooks = (hooksConfig.hooks ?? {});
+    const stopHooks = (hooks.Stop ?? []);
+    // 既に登録済みならスキップ
+    const alreadyRegistered = stopHooks.some((group) => group.hooks?.some((h) => h.command === RELIC_HOOK_COMMAND));
+    if (alreadyRegistered)
+        return;
+    hooks.Stop = [
+        ...stopHooks,
+        {
+            hooks: [
+                {
+                    type: "command",
+                    command: RELIC_HOOK_COMMAND,
+                    timeout: 5,
+                },
+            ],
+        },
+    ];
+    hooksConfig.hooks = hooks;
+    writeFileSync(CODEX_HOOKS_PATH, JSON.stringify(hooksConfig, null, 2), "utf-8");
+}
+/**
+ * Stop フックがセットアップ済みか確認する。
+ */
+export function isCodexHookSetup() {
+    if (!existsSync(CODEX_HOOK_SCRIPT_PATH))
+        return false;
+    if (!existsSync(CODEX_HOOKS_PATH))
+        return false;
+    try {
+        const hooksConfig = JSON.parse(readFileSync(CODEX_HOOKS_PATH, "utf-8"));
+        const stopHooks = hooksConfig.hooks?.Stop ?? [];
+        return stopHooks.some((group) => group.hooks?.some((h) => h.command === RELIC_HOOK_COMMAND));
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -1,8 +1,11 @@
-import type { ShellLauncher, InjectionMode } from "../../core/ports/shell-launcher.js";
+import type { ShellLauncher, InjectionMode, ShellLaunchOptions } from "../../core/ports/shell-launcher.js";
 /**
  * Codex CLI アダプター
- * [PROMPT] 引数でEngramを初回メッセージとして注入し、
- * インタラクティブモードを継続する。
+ * `-c developer_instructions=<prompt>` でEngramをdeveloperロールとして注入する。
+ * user-messageよりシステムプロンプトに近い強度で注入できる。
+ *
+ * 初回起動時に Stop フックを ~/.codex/hooks.json に登録し、
+ * 各ターン終了後に会話ログを Engram archive に自動記録する。
  */
 export declare class CodexShell implements ShellLauncher {
     private readonly command;
@@ -10,5 +13,5 @@ export declare class CodexShell implements ShellLauncher {
     readonly injectionMode: InjectionMode;
     constructor(command?: string);
     isAvailable(): Promise<boolean>;
-    launch(prompt: string, extraArgs?: string[], cwd?: string): Promise<void>;
+    launch(prompt: string, options?: ShellLaunchOptions): Promise<void>;
 }

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

@@ -2,16 +2,20 @@ 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, writeCodexHookScript } from "./codex-hook.js";
 const execAsync = promisify(exec);
 /**
  * Codex CLI アダプター
- * [PROMPT] 引数でEngramを初回メッセージとして注入し、
- * インタラクティブモードを継続する。
+ * `-c developer_instructions=<prompt>` でEngramをdeveloperロールとして注入する。
+ * user-messageよりシステムプロンプトに近い強度で注入できる。
+ *
+ * 初回起動時に Stop フックを ~/.codex/hooks.json に登録し、
+ * 各ターン終了後に会話ログを Engram archive に自動記録する。
  */
 export class CodexShell {
     command;
     name = "Codex CLI";
-    injectionMode = "user-message";
+    injectionMode = "developer-message";
     constructor(command = "codex") {
         this.command = command;
     }
@@ -24,11 +28,24 @@ export class CodexShell {
             return false;
         }
     }
-    async launch(prompt, extraArgs = [], cwd) {
+    async launch(prompt, options) {
+        // フックスクリプトを毎回最新に更新
+        writeCodexHookScript();
+        // hooks.json への登録は初回のみ
+        if (!isCodexHookSetup()) {
+            console.log("Setting up Codex CLI Stop hook (first run only)...");
+            setupCodexHook();
+            console.log("Hook registered to ~/.codex/hooks.json");
+            console.log();
+        }
         const args = [
-            ...extraArgs,
-            wrapWithOverride(prompt),
+            "-c", `developer_instructions=${JSON.stringify(wrapWithOverride(prompt))}`,
+            "-c", "features.codex_hooks=true",
+            ...(options?.extraArgs ?? []),
         ];
-        await spawnShell(this.command, args, cwd);
+        const env = {};
+        if (options?.engramId)
+            env.RELIC_ENGRAM_ID = options.engramId;
+        await spawnShell(this.command, args, options?.cwd, Object.keys(env).length > 0 ? env : undefined);
     }
 }

package/dist/adapters/shells/copilot-shell.d.ts

@@ -1,4 +1,4 @@
-import type { ShellLauncher, InjectionMode } from "../../core/ports/shell-launcher.js";
+import type { ShellLauncher, InjectionMode, ShellLaunchOptions } from "../../core/ports/shell-launcher.js";
 /**
  * GitHub Copilot CLI アダプター (copilot コマンド)
  * --interactive フラグでEngramを初回プロンプトとして注入し、
@@ -10,5 +10,5 @@ export declare class CopilotShell implements ShellLauncher {
     readonly injectionMode: InjectionMode;
     constructor(command?: string);
     isAvailable(): Promise<boolean>;
-    launch(prompt: string, extraArgs?: string[], cwd?: string): Promise<void>;
+    launch(prompt: string, options?: ShellLaunchOptions): Promise<void>;
 }

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

@@ -25,16 +25,16 @@ export class CopilotShell {
             return false;
         }
     }
-    async launch(prompt, extraArgs = [], cwd) {
+    async launch(prompt, options) {
         const tmp = writeTempPrompt(wrapWithOverride(prompt));
         try {
             const fileContent = readFileSync(tmp.path, "utf-8");
             const args = [
                 "--interactive",
                 fileContent,
-                ...extraArgs,
+                ...(options?.extraArgs ?? []),
             ];
-            await spawnShell(this.command, args, cwd);
+            await spawnShell(this.command, args, options?.cwd);
         }
         finally {
             tmp.cleanup();

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

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

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

@@ -0,0 +1,111 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+const RELIC_DIR = join(homedir(), ".relic");
+const HOOKS_DIR = join(RELIC_DIR, "hooks");
+export const GEMINI_HOOK_SCRIPT_PATH = join(HOOKS_DIR, "gemini-after-agent.js");
+const GEMINI_SETTINGS_PATH = join(homedir(), ".gemini", "settings.json");
+const RELIC_HOOK_NAME = "relic-archive-log";
+/**
+ * AfterAgent hook スクリプトの内容。
+ * Gemini CLI の各ターン終了後に発火し、会話ログを Engram archive に追記する。
+ * RELIC_ENGRAM_ID 環境変数で対象 Engram ID を受け取る。
+ */
+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, mkdirSync } = require("node:fs");
+const { join, dirname } = require("node:path");
+const { homedir } = require("node:os");
+
+let raw = "";
+process.stdin.setEncoding("utf-8");
+process.stdin.on("data", (chunk) => { raw += chunk; });
+process.stdin.on("end", () => {
+  try {
+    const input = JSON.parse(raw);
+    const engramId = process.env.RELIC_ENGRAM_ID;
+    if (!engramId) process.exit(0);
+
+    const prompt = (input.prompt || "").trim();
+    const response = (input.prompt_response || "").trim();
+    if (!prompt && !response) process.exit(0);
+
+    const archivePath = join(homedir(), ".relic", "engrams", engramId, "archive.md");
+    mkdirSync(dirname(archivePath), { recursive: true });
+
+    const date = new Date().toISOString().split("T")[0];
+    const summary = prompt.slice(0, 80).replace(/\\n/g, " ");
+    const entry = \`\\n---\\n\${date} | \${summary}\\n\${response}\\n\`;
+    appendFileSync(archivePath, entry, "utf-8");
+  } catch {
+    // silently ignore
+  }
+  process.exit(0);
+});
+`;
+/**
+ * フックスクリプトを最新の内容で書き出す。
+ * 毎回呼ばれ、ソース変更がデプロイされることを保証する。
+ */
+export function writeGeminiHookScript() {
+    mkdirSync(HOOKS_DIR, { recursive: true });
+    writeFileSync(GEMINI_HOOK_SCRIPT_PATH, HOOK_SCRIPT, { encoding: "utf-8", mode: 0o755 });
+}
+/**
+ * Gemini CLI の AfterAgent フックを settings.json に登録する。
+ * 既にセットアップ済みの場合はスキップ。
+ */
+export function setupGeminiHook() {
+    // ~/.gemini/settings.json にフックを登録
+    const geminiDir = join(homedir(), ".gemini");
+    mkdirSync(geminiDir, { recursive: true });
+    let settings = {};
+    if (existsSync(GEMINI_SETTINGS_PATH)) {
+        try {
+            settings = JSON.parse(readFileSync(GEMINI_SETTINGS_PATH, "utf-8"));
+        }
+        catch {
+            settings = {};
+        }
+    }
+    const hooks = (settings.hooks ?? {});
+    const afterAgentHooks = (hooks.AfterAgent ?? []);
+    // 既に登録済みならスキップ
+    const alreadyRegistered = afterAgentHooks.some((group) => group.hooks?.some((h) => h.name === RELIC_HOOK_NAME));
+    if (alreadyRegistered)
+        return;
+    hooks.AfterAgent = [
+        ...afterAgentHooks,
+        {
+            hooks: [
+                {
+                    type: "command",
+                    command: `node ${GEMINI_HOOK_SCRIPT_PATH}`,
+                    name: RELIC_HOOK_NAME,
+                    timeout: 5000,
+                },
+            ],
+        },
+    ];
+    settings.hooks = hooks;
+    writeFileSync(GEMINI_SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf-8");
+}
+/**
+ * AfterAgent フックがセットアップ済みか確認する。
+ */
+export function isGeminiHookSetup() {
+    if (!existsSync(GEMINI_HOOK_SCRIPT_PATH))
+        return false;
+    if (!existsSync(GEMINI_SETTINGS_PATH))
+        return false;
+    try {
+        const settings = JSON.parse(readFileSync(GEMINI_SETTINGS_PATH, "utf-8"));
+        const afterAgentHooks = settings.hooks?.AfterAgent ?? [];
+        return afterAgentHooks.some((group) => group.hooks?.some((h) => h.name === RELIC_HOOK_NAME));
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -1,8 +1,10 @@
-import type { ShellLauncher, InjectionMode } from "../../core/ports/shell-launcher.js";
+import type { ShellLauncher, InjectionMode, ShellLaunchOptions } from "../../core/ports/shell-launcher.js";
 /**
  * Gemini CLI アダプター
- * プロンプトをtempファイルに書き出し、
- * --prompt-interactive で読み込んで注入する。
+ * GEMINI_SYSTEM_MD 環境変数でシステムプロンプトを完全上書きし、
+ * Engramを組み込みプロンプトと合成して注入する。
+ *
+ * 初回起動時のみ GEMINI_WRITE_SYSTEM_MD でデフォルトプロンプトをキャプチャ・キャッシュする。
  */
 export declare class GeminiShell implements ShellLauncher {
     private readonly command;
@@ -10,5 +12,5 @@ export declare class GeminiShell implements ShellLauncher {
     readonly injectionMode: InjectionMode;
     constructor(command?: string);
     isAvailable(): Promise<boolean>;
-    launch(prompt: string, extraArgs?: string[], cwd?: string): Promise<void>;
+    launch(prompt: string, options?: ShellLaunchOptions): Promise<void>;
 }

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

@@ -1,18 +1,89 @@
+import { spawn } from "node:child_process";
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
-import { readFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+import { homedir, tmpdir } from "node:os";
 import { spawnShell, writeTempPrompt } from "./spawn-shell.js";
-import { wrapWithOverride } from "./override-preamble.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");
+const RELIC_ENGRAM_START = "<!-- RELIC ENGRAM START -->";
+const RELIC_ENGRAM_END = "<!-- RELIC ENGRAM END -->";
+/**
+ * GEMINI_WRITE_SYSTEM_MD=true で gemini を一時起動し、
+ * 組み込みシステムプロンプトをキャプチャして返す。
+ * キャプチャ結果は ~/.relic/gemini-system-default.md にキャッシュされる。
+ */
+async function captureDefaultSystemPrompt(command) {
+    const tempDir = mkdtempSync(join(tmpdir(), "relic-gemini-capture-"));
+    const geminiDir = join(tempDir, ".gemini");
+    mkdirSync(geminiDir, { recursive: true });
+    try {
+        await new Promise((resolve) => {
+            const child = spawn(command, [], {
+                cwd: tempDir,
+                env: { ...process.env, GEMINI_WRITE_SYSTEM_MD: "true" },
+                // stdin を /dev/null 相当にして TTY なしで起動
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            // ファイル書き出し猶予として5秒後に強制終了
+            const timeout = setTimeout(() => {
+                child.kill("SIGTERM");
+            }, 5000);
+            child.on("close", () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+            child.on("error", () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+        const systemMdPath = join(geminiDir, "system.md");
+        if (!existsSync(systemMdPath)) {
+            throw new Error("Failed to capture Gemini default system prompt.\n" +
+                "Run manually: GEMINI_WRITE_SYSTEM_MD=true gemini\n" +
+                `Then copy .gemini/system.md to ${GEMINI_DEFAULT_CACHE}`);
+        }
+        const content = readFileSync(systemMdPath, "utf-8");
+        mkdirSync(RELIC_DIR, { recursive: true });
+        writeFileSync(GEMINI_DEFAULT_CACHE, content, "utf-8");
+        return content;
+    }
+    finally {
+        rmSync(tempDir, { recursive: true, force: true });
+    }
+}
+/**
+ * デフォルトプロンプトにEngramセクションを追記 or 置換する（冪等）。
+ * <!-- RELIC ENGRAM START/END --> デリミタで管理する。
+ */
+function composeSystemPrompt(defaultPrompt, engramPrompt) {
+    const engramSection = [
+        RELIC_ENGRAM_START,
+        engramPrompt,
+        RELIC_ENGRAM_END,
+    ].join("\n");
+    if (defaultPrompt.includes(RELIC_ENGRAM_START)) {
+        // 既存のRELICセクションを置換
+        return defaultPrompt.replace(new RegExp(`${RELIC_ENGRAM_START}[\\s\\S]*?${RELIC_ENGRAM_END}`), engramSection);
+    }
+    // 末尾に追記
+    return `${defaultPrompt}\n\n${engramSection}`;
+}
 /**
  * Gemini CLI アダプター
- * プロンプトをtempファイルに書き出し、
- * --prompt-interactive で読み込んで注入する。
+ * GEMINI_SYSTEM_MD 環境変数でシステムプロンプトを完全上書きし、
+ * Engramを組み込みプロンプトと合成して注入する。
+ *
+ * 初回起動時のみ GEMINI_WRITE_SYSTEM_MD でデフォルトプロンプトをキャプチャ・キャッシュする。
  */
 export class GeminiShell {
     command;
     name = "Gemini CLI";
-    injectionMode = "user-message";
+    injectionMode = "system-prompt";
     constructor(command = "gemini") {
         this.command = command;
     }
@@ -25,16 +96,36 @@ export class GeminiShell {
             return false;
         }
     }
-    async launch(prompt, extraArgs = [], cwd) {
-        const tmp = writeTempPrompt(wrapWithOverride(prompt));
+    async launch(prompt, options) {
+        // 1. フックスクリプトを毎回最新に更新
+        writeGeminiHookScript();
+        // settings.json への登録は初回のみ
+        if (!isGeminiHookSetup()) {
+            console.log("Setting up Gemini AfterAgent hook (first run only)...");
+            setupGeminiHook();
+            console.log("Hook registered to ~/.gemini/settings.json");
+            console.log();
+        }
+        // 2. デフォルトシステムプロンプトをキャッシュから読む、なければキャプチャ
+        let defaultPrompt;
+        if (existsSync(GEMINI_DEFAULT_CACHE)) {
+            defaultPrompt = readFileSync(GEMINI_DEFAULT_CACHE, "utf-8");
+        }
+        else {
+            console.log("Capturing Gemini default system prompt (first run only)...");
+            defaultPrompt = await captureDefaultSystemPrompt(this.command);
+            console.log(`Cached to: ${GEMINI_DEFAULT_CACHE}`);
+            console.log();
+        }
+        // 3. デフォルト + Engram を合成してtempファイルに書き出す
+        const combined = composeSystemPrompt(defaultPrompt, prompt);
+        const tmp = writeTempPrompt(combined);
         try {
-            const fileContent = readFileSync(tmp.path, "utf-8");
-            const args = [
-                "--prompt-interactive",
-                fileContent,
-                ...extraArgs,
-            ];
-            await spawnShell(this.command, args, cwd);
+            // 4. GEMINI_SYSTEM_MD + RELIC_ENGRAM_ID でシステムプロンプトを差し替えて起動
+            const env = { GEMINI_SYSTEM_MD: tmp.path };
+            if (options?.engramId)
+                env.RELIC_ENGRAM_ID = options.engramId;
+            await spawnShell(this.command, [...(options?.extraArgs ?? [])], options?.cwd, env);
         }
         finally {
             tmp.cleanup();

package/dist/adapters/shells/index.d.ts

@@ -1,4 +1,3 @@
 export { ClaudeShell } from "./claude-shell.js";
 export { GeminiShell } from "./gemini-shell.js";
 export { CodexShell } from "./codex-shell.js";
-export { CopilotShell } from "./copilot-shell.js";

package/dist/adapters/shells/index.js

@@ -1,4 +1,3 @@
 export { ClaudeShell } from "./claude-shell.js";
 export { GeminiShell } from "./gemini-shell.js";
 export { CodexShell } from "./codex-shell.js";
-export { CopilotShell } from "./copilot-shell.js";

package/dist/adapters/shells/spawn-shell.d.ts

@@ -5,7 +5,7 @@
  * shell: false で起動し、引数をそのまま渡す。
  * これにより長いプロンプト文字列がシェルに壊されない。
  */
-export declare function spawnShell(command: string, args: string[], cwd?: string): Promise<void>;
+export declare function spawnShell(command: string, args: string[], cwd?: string, env?: Record<string, string>): Promise<void>;
 /**
  * プロンプトをtempファイルに書き出し、パスを返す。
  * Shell終了後にcleanup()を呼んで削除する。

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

@@ -9,17 +9,24 @@ import { tmpdir } from "node:os";
  * shell: false で起動し、引数をそのまま渡す。
  * これにより長いプロンプト文字列がシェルに壊されない。
  */
-export function spawnShell(command, args, cwd) {
+export function spawnShell(command, args, cwd, env) {
     return new Promise((resolve, reject) => {
         const child = spawn(command, args, {
             stdio: "inherit",
             cwd,
+            env: env ? { ...process.env, ...env } : undefined,
         });
         child.on("error", (err) => {
             reject(new Error(`Failed to launch ${command}: ${err.message}`));
         });
-        child.on("close", (code) => {
-            if (code === 0 || code === null) {
+        child.on("close", (code, signal) => {
+            // code 0 = 正常終了
+            // code null = シグナルで終了
+            // signal SIGINT/SIGTERM = ユーザーによる中断（正常扱い）
+            if (code === 0 ||
+                code === null ||
+                signal === "SIGINT" ||
+                signal === "SIGTERM") {
                 resolve();
             }
             else {