@minimalcorp/tsunagi 0.3.3 → 0.4.0

package/dist/server/lib/pty-launch.js

@@ -6,11 +6,8 @@ import { ptyManager } from '../pty-manager.js';
 import { prisma } from './db.js';
 import { getWorktreePath } from './worktree-manager.js';
 import { getEnv } from './repositories/environment.js';
-import { ensureClaudeOnboardingCompleted, removeLocalModelFromUserSettings, watchUserSettingsForLocalModel, } from './claude-config-guard.js';
-import { LOCAL_LLM_UNSET_ENV_KEYS, LOCAL_MODEL_ALIAS, buildLocalLlmEnv } from './local-llm-env.js';
-import { ensureActiveLoaded, getLocalLlmSettings } from './local-llm.js';
-import { LOCAL_LLM_PROXY_URL, buildClaudeCommand, isLocalLlmMode } from './claude-command.js';
-import { resolveClaudeProfileEnv } from './claude-profiles.js';
+import { resolveAgentProfileEnv } from './agent-profiles.js';
+import { AgentLaunchError as PtyLaunchError, getAgentForMode } from './agents/index.js';
 // このファイル基準で解決する(cwd 非依存):
 //   dev:        apps/server/src/lib      → apps/server/scripts
 //   build:      apps/server/dist/lib     → apps/server/scripts
@@ -19,17 +16,11 @@ const TSUNAGI_EDITOR_PATH = path.resolve(path.dirname(fileURLToPath(import.meta.
 // Fastify(API) の公開ポート。index.ts と同じ既定値・同じ環境変数(TSUNAGI_SERVER_PORT)を見る。
 // monaco-editor.sh など PTY 内のプロセスが API を叩く際の同一ホスト向けベース URL に使う。
 const SERVER_PORT = Number(process.env.TSUNAGI_SERVER_PORT) || 2791;
-export class PtyLaunchError extends Error {
-    statusCode;
-    constructor(message, statusCode) {
-        super(message);
-        this.statusCode = statusCode;
-    }
-}
+export { PtyLaunchError };
 /**
  * sessionId(=tab_id) から PTY の作業ディレクトリと環境変数を解決する。
- * 環境変数の優先順位: リクエストで渡されたenv > ローカルLLMのprovider env >
- * DB env(global/owner/repo、Claude プロファイルを CLAUDE_CONFIG_DIR に変換) > tsunagi独自のEDITOR設定
+ * 環境変数の優先順位: リクエストで渡されたenv > エージェント固有のenv（ローカルLLMの provider 等） >
+ * DB env(global/owner/repo、エージェントのプロファイルを設定ディレクトリに変換) > tsunagi独自のEDITOR設定
  */
 export async function resolvePtyLaunch(sessionId, request) {
     // Taskに紐づかないタブは Tab レコードが存在しないため null になる。
@@ -57,24 +48,12 @@ export async function resolvePtyLaunch(sessionId, request) {
     // Taskに紐づかないタブは global のみになる。
     // 読み込みに失敗したら起動しない（空の環境変数で起動・作り直しすると設定が抜け落ちるため）
     const dbEnv = tab ? await getEnv('repo', tab.task.owner, tab.task.repo) : await getEnv('global');
-    const profile = resolveClaudeProfileEnv(dbEnv);
-    // ローカルLLMタブ: Anthropic の代わりに tsunagi の中継口（→ Ollama / LM Studio）で claude を動かす。
-    // DB の環境変数より後に適用し、Anthropic の認証トークンは環境変数ごと取り除く。
+    const profile = resolveAgentProfileEnv(dbEnv);
+    // エージェント固有の環境変数は DB の環境変数より後に適用する
     const mode = tab?.mode;
-    let providerEnv = {};
-    let unsetKeys = profile.unsetKeys;
-    if (isLocalLlmMode(mode)) {
-        const { active, extraEnv } = await getLocalLlmSettings();
-        if (!active) {
-            throw new PtyLaunchError('ローカルLLMのモデルが未設定です。Settings で使用するモデルを選んでください', 400);
-        }
-        providerEnv = buildLocalLlmEnv({
-            proxyUrl: LOCAL_LLM_PROXY_URL,
-            contextTokens: active.contextTokens,
-            extraEnv,
-        });
-        unsetKeys = [...new Set([...unsetKeys, ...LOCAL_LLM_UNSET_ENV_KEYS])];
-    }
+    const agentEnv = await getAgentForMode(mode).resolveLaunchEnv(mode ?? 'claude');
+    const providerEnv = agentEnv.env;
+    const unsetKeys = [...new Set([...profile.unsetKeys, ...agentEnv.unsetKeys])];
     // tsunagi-editor.sh をデフォルトにすることで Ctrl+G が Monaco Modal を開く。
     // DB / リクエストで EDITOR が明示設定されている場合はそちらが優先される。
     const tsunagiDefaultEnv = {
@@ -93,41 +72,24 @@ export async function resolvePtyLaunch(sessionId, request) {
     };
 }
 /**
- * claude 起動前の補正。claude logout で .claude.json の hasCompletedOnboarding がリセットされて
- * いると、次回 claude 起動時にオンボーディングウィザードが表示され --resume/--session-id を前提にした
- * 自動起動フローが止まるため補正する。監視の取りこぼしに備え、中継口の名前が既定モデルに残って
- * いないかも補正する。対象はタブが使う Claude プロファイルの設定ディレクトリ。
- */
-async function prepareClaudeConfig(env) {
-    // PTY は外側 Terminal の環境を継承するため、プロファイル未指定なら外側の CLAUDE_CONFIG_DIR に従う
-    const configDir = env.CLAUDE_CONFIG_DIR ?? process.env.CLAUDE_CONFIG_DIR;
-    await ensureClaudeOnboardingCompleted(configDir);
-    await removeLocalModelFromUserSettings(LOCAL_MODEL_ALIAS, configDir);
-    watchUserSettingsForLocalModel(LOCAL_MODEL_ALIAS, configDir);
-}
-/**
- * 解決済みの launch で PTY を作り、claude を起動する。
+ * 解決済みの launch で PTY を作り、エージェントを起動する。
  * 新規作成（POST /terminal/sessions）と環境変数変更時の作り直し（pty-env-sync）で共用する。
  */
 export async function startPtySession(sessionId, launch, options) {
     await fs.mkdir(launch.workingDir, { recursive: true });
-    let command = options.command;
-    if (options.launchClaude) {
-        if (isLocalLlmMode(launch.mode)) {
-            // 最初の発言を待たせないよう読み込みを始めておく（完了は待たない）
-            ensureActiveLoaded().catch(() => undefined);
-        }
-        command = await buildClaudeCommand(sessionId, launch.mode ?? 'claude');
-    }
+    const agent = options.launchAgent ? getAgentForMode(launch.mode) : undefined;
+    const command = agent
+        ? await agent.buildCommand(sessionId, launch.mode ?? 'claude')
+        : options.command;
     const session = ptyManager.createSession(sessionId, launch.workingDir, launch.env, launch.unsetKeys, {
         request: options.request,
-        launchClaude: options.launchClaude,
+        launchAgent: options.launchAgent,
         syncEnv: true,
     });
     // コマンドが指定されていればPTY起動後にシェルへ書き込む
     if (command) {
         const cmd = command.endsWith('\n') ? command : command + '\n';
-        await prepareClaudeConfig(launch.env);
+        await agent?.prepareLaunch(launch.env);
         // シェルの初期化（プロンプト表示）を待つため少し遅延させて書き込む
         setTimeout(() => {
             session.pty.write(cmd);
@@ -135,7 +97,7 @@ export async function startPtySession(sessionId, launch, options) {
     }
     return session;
 }
-/** 既存 PTY で claude を（再）起動する前の補正。PTY 作成時の環境変数のプロファイルを対象にする */
-export async function prepareClaudeConfigForSession(session) {
-    await prepareClaudeConfig(session.appliedEnv);
+/** 既存 PTY でエージェントを（再）起動する前の補正。PTY 作成時の環境変数のプロファイルを対象にする */
+export async function prepareAgentLaunchForSession(session, mode) {
+    await getAgentForMode(mode)?.prepareLaunch(session.appliedEnv);
 }

package/dist/server/lib/repositories/task.js

@@ -243,6 +243,7 @@ function mapTab(tab) {
         mode: tab.mode,
         unread: tab.unread,
         todos: tab.todos ? JSON.parse(tab.todos) : [],
+        agentSessionId: tab.agentSessionId ?? undefined,
         startedAt: tab.startedAt.toISOString(),
         completedAt: tab.completedAt?.toISOString(),
         updatedAt: tab.updatedAt.toISOString(),

package/dist/server/lib/tab-todos.d.ts

@@ -10,3 +10,8 @@ export declare function parseTodos(raw: string | null | undefined): Todo[];
  * tsunagi 側も DB 上の todos を起点に差分を当てる（サーバー再起動でも進捗を失わない）
  */
 export declare function applyToolToTodos(current: Todo[], toolName: string | undefined, input: Record<string, unknown> | undefined, response: Record<string, unknown> | undefined): Todo[] | null;
+/**
+ * Codex の update_plan（PostToolUse の tool_input: { plan: [{ step, status }] }）を todos に変換する。
+ * 毎回計画全体が渡されるため全置換する。解釈できなければ null
+ */
+export declare function planToTodos(input: unknown): Todo[] | null;

package/dist/server/lib/tab-todos.js

@@ -137,3 +137,16 @@ export function applyToolToTodos(current, toolName, input, response) {
             return null;
     }
 }
+/**
+ * Codex の update_plan（PostToolUse の tool_input: { plan: [{ step, status }] }）を todos に変換する。
+ * 毎回計画全体が渡されるため全置換する。解釈できなければ null
+ */
+export function planToTodos(input) {
+    const plan = isRecord(input) ? input.plan : undefined;
+    if (!Array.isArray(plan))
+        return null;
+    return plan.filter(isRecord).map((item) => ({
+        content: String(item.step ?? ''),
+        status: isStatus(item.status) ? item.status : 'pending',
+    }));
+}

package/dist/server/pty-manager.d.ts

@@ -6,8 +6,8 @@ export interface PtySessionOptions {
         cwd?: string;
         env?: Record<string, string>;
     };
-    /** 作成時に claude を起動したか（作り直し後も claude を --resume で起動する） */
-    launchClaude?: boolean;
+    /** 作成時にエージェントを起動したか（作り直し後もエージェントを resume で起動する） */
+    launchAgent?: boolean;
     /** tsunagi の環境変数の変更を自動で反映する対象か（Claude のログイン用 PTY 等は対象外） */
     syncEnv?: boolean;
 }
@@ -77,4 +77,9 @@ declare class PtyManager {
     deleteAllSessions(): void;
 }
 export declare const ptyManager: PtyManager;
+/**
+ * PTY の前面がシェルか（エージェントなどのコマンドが動いていないか）。
+ * 判定できない環境（Windows）では true を返す
+ */
+export declare function isShellForeground(session: PtySession): boolean;
 export {};

package/dist/server/pty-manager.js

@@ -1,5 +1,6 @@
 import * as pty from 'node-pty';
 import * as os from 'os';
+import * as path from 'path';
 const SCROLLBACK_MAX_BYTES = 256 * 1024; // 256KB
 const SESSION_GC_INTERVAL_MS = 30 * 60 * 1000; // 30分
 /**
@@ -225,3 +226,15 @@ class PtyManager {
     }
 }
 export const ptyManager = new PtyManager();
+/** 前面にいればシェルのプロンプトとみなすプロセス名（ログインシェルの先頭の `-` は外して比べる） */
+const SHELL_NAMES = new Set(['bash', 'zsh', 'sh', 'dash', 'fish', 'ksh']);
+/**
+ * PTY の前面がシェルか（エージェントなどのコマンドが動いていないか）。
+ * 判定できない環境（Windows）では true を返す
+ */
+export function isShellForeground(session) {
+    if (os.platform() === 'win32')
+        return true;
+    const name = path.basename(session.pty.process).replace(/^-/, '');
+    return SHELL_NAMES.has(name) || name === path.basename(process.env.SHELL ?? '');
+}

package/dist/server/routes/agent-profiles.d.ts

@@ -0,0 +1,2 @@
+import type { FastifyInstance } from 'fastify';
+export declare function agentProfilesRoutes(fastify: FastifyInstance): Promise<void>;

package/dist/server/routes/agent-profiles.js

@@ -0,0 +1,193 @@
+import { mkdir } from 'fs/promises';
+import * as os from 'os';
+import { ptyManager } from '../pty-manager.js';
+import { prisma } from '../lib/db.js';
+import { deleteEnv, getEnv, setEnv } from '../lib/repositories/environment.js';
+import { AGENTS, getAgent, getAgentAvailability } from '../lib/agents/index.js';
+import { DEFAULT_PROFILE, LOGIN_SESSION_PREFIX, createProfile, deleteProfile, getProfileAuthStatus, listProfiles, loginPtyEnv, profileExists, } from '../lib/agent-profiles.js';
+import { notifyEnvChanged } from '../lib/pty-env-sync.js';
+import { forwardLoginCallback, needsLoginCallbackPaste } from '../lib/agents/login-callback.js';
+/** ログイン用 PTY の sessionId からエージェントを得る（`agent-login-<agent>-<slug>-<uuid>`） */
+function agentOfLoginSession(sessionId) {
+    return AGENTS.find((agent) => sessionId.startsWith(`${LOGIN_SESSION_PREFIX}${agent.id}-`));
+}
+function validateScope(scope, owner, repo) {
+    if (scope !== 'global' && scope !== 'owner' && scope !== 'repo')
+        return 'Invalid scope';
+    if (scope === 'owner' && !owner)
+        return 'owner is required for scope=owner';
+    if (scope === 'repo' && (!owner || !repo))
+        return 'owner and repo are required for scope=repo';
+    return null;
+}
+async function getAssignment(agent, scope, owner, repo) {
+    const { envKey } = agent.profile;
+    const row = await prisma.environmentVariable.findFirst({
+        where: {
+            key: envKey,
+            scope,
+            ...(scope !== 'global' && { owner }),
+            ...(scope === 'repo' && { repo }),
+        },
+    });
+    const merged = await getEnv(scope, owner, repo);
+    const assignment = {
+        assigned: row?.value ?? null,
+        effective: merged[envKey] ?? DEFAULT_PROFILE,
+    };
+    return assignment;
+}
+function syncPtyEnv(fastify) {
+    notifyEnvChanged().catch((err) => fastify.log.warn(err, 'Failed to sync PTY env'));
+}
+/** :agent を adapter に解決する。未知なら 404 を返して undefined */
+function resolveAgent(id, reply) {
+    const agent = getAgent(id);
+    if (!agent)
+        void reply.status(404).send({ error: 'Unknown agent' });
+    return agent;
+}
+export async function agentProfilesRoutes(fastify) {
+    // GET /agents - エージェント CLI の導入状況
+    fastify.get('/agents', async (_request, reply) => {
+        const agents = await Promise.all(AGENTS.map((agent) => getAgentAvailability(agent)));
+        return reply.send({ data: { agents } });
+    });
+    // GET /agent-profiles/:agent - システム既定 + 登録済みプロファイルとログイン状態
+    fastify.get('/agent-profiles/:agent', async (request, reply) => {
+        const agent = resolveAgent(request.params.agent, reply);
+        if (!agent)
+            return;
+        const profiles = await listProfiles(agent);
+        const data = await Promise.all([
+            getProfileAuthStatus(agent, DEFAULT_PROFILE).then((status) => ({
+                agent: agent.id,
+                slug: DEFAULT_PROFILE,
+                name: 'System default',
+                // 設定ディレクトリの環境変数を付けない（普段ターミナルで CLI を使うときと同じ設定）
+                configDir: null,
+                status,
+            })),
+            ...profiles.map(async (profile) => ({
+                ...profile,
+                status: await getProfileAuthStatus(agent, profile.slug),
+            })),
+        ]);
+        return reply.send({ data: { profiles: data } });
+    });
+    // GET /agent-profiles/:agent/:slug/status - ログイン状態（ログイン用ダイアログで完了を確認する）
+    fastify.get('/agent-profiles/:agent/:slug/status', async (request, reply) => {
+        const agent = resolveAgent(request.params.agent, reply);
+        if (!agent)
+            return;
+        const { slug } = request.params;
+        if (!(await profileExists(agent, slug))) {
+            return reply.status(404).send({ error: 'Profile not found' });
+        }
+        return reply.send({ data: { status: await getProfileAuthStatus(agent, slug) } });
+    });
+    // POST /agent-profiles/:agent - プロファイル作成
+    fastify.post('/agent-profiles/:agent', async (request, reply) => {
+        const agent = resolveAgent(request.params.agent, reply);
+        if (!agent)
+            return;
+        try {
+            const profile = await createProfile(agent, request.body?.name ?? '');
+            return reply.status(201).send({ data: { profile } });
+        }
+        catch (err) {
+            return reply.status(400).send({ error: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    // DELETE /agent-profiles/:agent/:slug - プロファイル削除（logout してディレクトリごと消す）
+    fastify.delete('/agent-profiles/:agent/:slug', async (request, reply) => {
+        const agent = resolveAgent(request.params.agent, reply);
+        if (!agent)
+            return;
+        const { slug } = request.params;
+        if (slug === DEFAULT_PROFILE || !(await profileExists(agent, slug))) {
+            return reply.status(404).send({ error: 'Profile not found' });
+        }
+        await deleteProfile(agent, slug);
+        syncPtyEnv(fastify);
+        return reply.status(204).send();
+    });
+    // POST /agent-profiles/:agent/:slug/login - ログイン用 PTY を起動しログインコマンドを実行する
+    fastify.post('/agent-profiles/:agent/:slug/login', async (request, reply) => {
+        const agent = resolveAgent(request.params.agent, reply);
+        if (!agent)
+            return;
+        const { slug } = request.params;
+        if (!(await profileExists(agent, slug))) {
+            return reply.status(404).send({ error: 'Profile not found' });
+        }
+        // 古いログイン用 PTY はここでは閉じない（同時に届いた要求どうしで、相手が表示中の PTY を閉じてしまう）。
+        // ダイアログを閉じたときにクライアントが DELETE する
+        const sessionId = `${LOGIN_SESSION_PREFIX}${agent.id}-${slug}-${crypto.randomUUID()}`;
+        const { env, unsetKeys } = loginPtyEnv(agent, slug);
+        const configDir = env[agent.profile.configDirEnvKey];
+        // CODEX_HOME は存在しないと codex が起動しない
+        if (configDir)
+            await mkdir(configDir, { recursive: true });
+        const session = ptyManager.createSession(sessionId, os.homedir(), env, unsetKeys);
+        // シェルの初期化（プロンプト表示）を待つため少し遅延させて書き込む
+        setTimeout(() => session.pty.write(`${agent.profile.loginCommand}\n`), 300);
+        // ブラウザから CLI の待ち受けに届かない環境では、開けなかった URL を貼り付けてもらう
+        const callbackPaste = Boolean(agent.profile.loginCallbackPorts) && needsLoginCallbackPaste();
+        return reply.status(201).send({ data: { sessionId, callbackPaste } });
+    });
+    // DELETE /agent-profiles/login/:sessionId - ログイン用 PTY を閉じる
+    fastify.delete('/agent-profiles/login/:sessionId', async (request, reply) => {
+        const { sessionId } = request.params;
+        if (!sessionId.startsWith(LOGIN_SESSION_PREFIX)) {
+            return reply.status(400).send({ error: 'Not a login session' });
+        }
+        ptyManager.deleteSession(sessionId);
+        return reply.status(204).send();
+    });
+    // POST /agent-profiles/login/:sessionId/callback - ブラウザで開けなかった戻り先の URL を CLI に渡す
+    fastify.post('/agent-profiles/login/:sessionId/callback', async (request, reply) => {
+        const { sessionId } = request.params;
+        const ports = agentOfLoginSession(sessionId)?.profile.loginCallbackPorts;
+        if (!ports || !ptyManager.getSession(sessionId)) {
+            return reply.status(404).send({ error: 'Login session not found' });
+        }
+        const error = await forwardLoginCallback(request.body?.url ?? '', ports);
+        if (error)
+            return reply.status(400).send({ error });
+        return reply.send({ data: { forwarded: true } });
+    });
+    // GET /agent-profiles/:agent/assignment - スコープのプロファイル割り当て
+    fastify.get('/agent-profiles/:agent/assignment', async (request, reply) => {
+        const agent = resolveAgent(request.params.agent, reply);
+        if (!agent)
+            return;
+        const { scope, owner, repo } = request.query;
+        const error = validateScope(scope, owner, repo);
+        if (error)
+            return reply.status(400).send({ error });
+        return reply.send({ data: { assignment: await getAssignment(agent, scope, owner, repo) } });
+    });
+    // PUT /agent-profiles/:agent/assignment - スコープのプロファイル割り当てを変更する
+    fastify.put('/agent-profiles/:agent/assignment', async (request, reply) => {
+        const agent = resolveAgent(request.params.agent, reply);
+        if (!agent)
+            return;
+        const { scope, owner, repo, slug } = request.body ?? {};
+        const error = validateScope(scope, owner, repo);
+        if (error)
+            return reply.status(400).send({ error });
+        if (slug !== null && !(await profileExists(agent, slug))) {
+            return reply.status(400).send({ error: 'Profile not found' });
+        }
+        const { envKey } = agent.profile;
+        if (slug === null) {
+            await deleteEnv(envKey, scope, owner, repo);
+        }
+        else {
+            await setEnv(envKey, slug, scope, owner, repo);
+        }
+        syncPtyEnv(fastify);
+        return reply.send({ data: { assignment: await getAssignment(agent, scope, owner, repo) } });
+    });
+}

package/dist/server/routes/env.js

@@ -1,7 +1,7 @@
 import * as envRepo from '../lib/repositories/environment.js';
-import { RESERVED_ENV_KEYS } from '../lib/claude-profiles.js';
+import { RESERVED_ENV_KEYS } from '../lib/agent-profiles.js';
 import { notifyEnvChanged } from '../lib/pty-env-sync.js';
-const RESERVED_KEY_ERROR = 'Claude の認証は Settings の Claude Profile で設定してください';
+const RESERVED_KEY_ERROR = 'エージェントの認証は Settings の Claude Profile / Codex Profile で設定してください';
 /** 変更後、起動中のターミナルに反映する（失敗しても API 自体は成功扱い） */
 function syncPtyEnv(fastify) {
     notifyEnvChanged().catch((err) => fastify.log.warn(err, 'Failed to sync PTY env'));

package/dist/server/routes/hooks.d.ts

@@ -1,25 +1,10 @@
 import type { FastifyInstance } from 'fastify';
-interface ClaudeHookBody {
-    hook_event_name: string;
-    session_id?: string;
-    transcript_path?: string;
-    cwd?: string;
-    permission_mode?: string;
-    prompt?: string;
-    tool_name?: string;
-    tool_use_id?: string;
-    tool_input?: Record<string, unknown>;
-    tool_response?: Record<string, unknown>;
-    error?: string;
-    error_details?: string;
-    reason?: string;
-}
 export interface HookEvent {
     receivedAt: string;
-    event: string;
-    sessionId?: string;
-    raw: ClaudeHookBody;
+    agent: string;
+    event?: string;
+    tabId?: string;
+    raw: Record<string, unknown>;
 }
 export declare const hookEvents: HookEvent[];
 export declare function hooksRoutes(fastify: FastifyInstance): Promise<void>;
-export {};

package/dist/server/routes/hooks.js

@@ -1,10 +1,11 @@
 import { prisma } from '../lib/db.js';
-import { applyToolToTodos, parseTodos, TODO_TOOL_NAMES } from '../lib/tab-todos.js';
+import { parseTodos } from '../lib/tab-todos.js';
+import { getAgent } from '../lib/agents/index.js';
 export const hookEvents = [];
 /**
  * status から未読フラグを導出する。
  * 完了(success/error)で未読を立て、再実行・セッション終了で落とす。
- * web 側 (apps/web/src/lib/claude-status.ts の unreadForStatus) と同じルール。
+ * web 側 (apps/web/src/lib/agent-status.ts の unreadForStatus) と同じルール。
  */
 function unreadForStatus(status) {
     switch (status) {
@@ -68,88 +69,97 @@ async function updateTabStatus(sessionId, status, todos) {
         return { count: 0 };
     }
 }
+/** 正規化した hook イベントでタブの状態を更新し、購読中のクライアントに通知する */
+async function applyHookEvent(fastify, io, event) {
+    const { tabId } = event;
+    const room = `tab:${tabId}`;
+    const setStatus = async (status, emitted = status) => {
+        await updateTabStatus(tabId, status);
+        io.to(room).emit('status-changed', { sessionId: tabId, status: emitted });
+    };
+    switch (event.kind) {
+        case 'session-start':
+            // エージェントが起動しただけ（まだプロンプト処理していない）→ idleのまま通知のみ。
+            // タブIDと別のセッションIDを振るエージェント（Codex）は、次回の resume 用に保存する
+            if (event.agentSessionId) {
+                await prisma.tab
+                    .updateMany({ where: { tabId }, data: { agentSessionId: event.agentSessionId } })
+                    .catch((err) => fastify.log.warn(err, '[hooks] Failed to save agent session id'));
+            }
+            io.to(room).emit('status-changed', { sessionId: tabId, status: 'idle' });
+            break;
+        case 'prompt':
+            // プロンプト送信開始 → running
+            await setStatus('running');
+            break;
+        case 'permission':
+            // ツール実行許可待ち → waiting
+            await setStatus('waiting');
+            break;
+        case 'tool-post': {
+            // ツール実行完了（許可待ち後のAllow含む）→ runningに戻す。todos を更新するツールなら todos も更新する
+            const { applyTodos } = event;
+            const todosUpdated = applyTodos !== undefined &&
+                (await withTodosLock(tabId, async () => {
+                    const todos = applyTodos(await loadTabTodos(tabId));
+                    if (!todos) {
+                        fastify.log.debug({ tabId, tool: event.toolName }, '[hooks] todo tool ignored (unknown task or unexpected payload)');
+                        return false;
+                    }
+                    const { count } = await updateTabStatus(tabId, 'running', todos);
+                    fastify.log.info({ tabId, tool: event.toolName, todosCount: todos.length, updatedTabCount: count }, '[hooks] todos updated');
+                    io.to(room).emit('todos-updated', { sessionId: tabId, todos });
+                    return true;
+                }));
+            if (!todosUpdated) {
+                await updateTabStatus(tabId, 'running');
+            }
+            io.to(room).emit('status-changed', { sessionId: tabId, status: 'running' });
+            break;
+        }
+        case 'stop':
+            // 正常完了 → success
+            await setStatus('success');
+            break;
+        case 'stop-failure':
+            // APIエラーでターン終了 → error
+            // todos は残す（エージェント側の進捗はセッションに永続化され、resume 後も続きから使われる）
+            await setStatus('error', 'failure');
+            break;
+        case 'interrupt':
+        case 'session-end':
+            // 中断・セッション終了 → idle（todos は stop-failure と同じ理由で残す）
+            await setStatus('idle');
+            break;
+    }
+}
 export async function hooksRoutes(fastify) {
     const io = fastify.io;
-    // POST /hooks/claude - Claude CLIからのhook受信
-    fastify.post('/hooks/claude', async (request, reply) => {
-        const body = request.body;
-        const eventName = body.hook_event_name;
-        const sessionId = body.session_id;
-        fastify.log.info({ eventName, sessionId }, 'Claude hook received');
+    // POST /hooks/:agent - エージェント CLI からの hook 受信
+    fastify.post('/hooks/:agent', async (request, reply) => {
+        const adapter = getAgent(request.params.agent);
+        if (!adapter)
+            return reply.status(404).send({ error: 'Unknown agent' });
+        const body = request.body ?? {};
+        const event = adapter.normalizeHook({ body, headers: request.headers });
+        const eventName = typeof body.hook_event_name === 'string' ? body.hook_event_name : undefined;
+        fastify.log.info({ agent: adapter.id, eventName, tabId: event?.tabId }, 'Agent hook received');
         // メモリに記録（確認用）
         hookEvents.push({
             receivedAt: new Date().toISOString(),
+            agent: adapter.id,
             event: eventName,
-            sessionId,
+            tabId: event?.tabId,
             raw: body,
         });
         // 最新100件のみ保持
         if (hookEvents.length > 100)
             hookEvents.splice(0, hookEvents.length - 100);
-        if (sessionId) {
-            const room = `tab:${sessionId}`;
-            switch (eventName) {
-                case 'SessionStart':
-                    // claudeが起動しただけ（まだプロンプト処理していない）→ idleのまま通知のみ
-                    io.to(room).emit('status-changed', { sessionId, status: 'idle' });
-                    break;
-                case 'UserPromptSubmit':
-                    // プロンプト送信開始 → running状態に更新
-                    await updateTabStatus(sessionId, 'running');
-                    io.to(room).emit('status-changed', { sessionId, status: 'running' });
-                    break;
-                case 'PermissionRequest':
-                    // ツール実行許可待ち → waiting状態に更新
-                    await updateTabStatus(sessionId, 'waiting');
-                    io.to(room).emit('status-changed', { sessionId, status: 'waiting' });
-                    break;
-                case 'PostToolUse': {
-                    // ツール実行完了（PermissionRequest後のAllow含む）→ runningに戻す
-                    // TodoWrite / Task 系ツールなら todos も更新する
-                    const toolName = body.tool_name;
-                    const todosUpdated = toolName !== undefined &&
-                        TODO_TOOL_NAMES.has(toolName) &&
-                        (await withTodosLock(sessionId, async () => {
-                            const todos = applyToolToTodos(await loadTabTodos(sessionId), toolName, body.tool_input, body.tool_response);
-                            if (!todos) {
-                                fastify.log.debug({ sessionId, tool: toolName, input: body.tool_input }, '[hooks] todo tool ignored (unknown task or unexpected payload)');
-                                return false;
-                            }
-                            const { count } = await updateTabStatus(sessionId, 'running', todos);
-                            fastify.log.info({ sessionId, tool: toolName, todosCount: todos.length, updatedTabCount: count }, '[hooks] todos updated');
-                            io.to(room).emit('todos-updated', { sessionId, todos });
-                            return true;
-                        }));
-                    if (!todosUpdated) {
-                        await updateTabStatus(sessionId, 'running');
-                    }
-                    io.to(room).emit('status-changed', { sessionId, status: 'running' });
-                    break;
-                }
-                case 'PreToolUse':
-                    // ログ記録のみ
-                    break;
-                case 'Stop':
-                    // 正常完了 → success状態に更新
-                    await updateTabStatus(sessionId, 'success');
-                    io.to(room).emit('status-changed', { sessionId, status: 'success' });
-                    break;
-                case 'StopFailure':
-                    // APIエラーでターン終了 → failure状態に更新
-                    // todos は残す（Claude 側の Task はセッションに永続化され、--resume 後も続きから使われる）
-                    await updateTabStatus(sessionId, 'error');
-                    io.to(room).emit('status-changed', { sessionId, status: 'failure' });
-                    break;
-                case 'SessionEnd':
-                    // セッション終了（Escキー中断・Ctrl+C・/exit等）→ idle状態に更新（todos は StopFailure と同じ理由で残す）
-                    // reason: "prompt_input_exit" = ユーザー中断、"other" = プロセスkill等
-                    fastify.log.info({ sessionId, reason: body.reason }, 'SessionEnd received');
-                    await updateTabStatus(sessionId, 'idle');
-                    io.to(room).emit('status-changed', { sessionId, status: 'idle' });
-                    break;
-                default:
-                    fastify.log.debug({ eventName }, 'Unhandled hook event');
-            }
+        if (event) {
+            await applyHookEvent(fastify, io, event);
+        }
+        else {
+            fastify.log.debug({ agent: adapter.id, eventName }, 'Unhandled hook event');
         }
         return reply.status(200).send({ ok: true });
     });

package/dist/server/routes/mcp.js

@@ -22,7 +22,7 @@ const taskIdentifierProperties = {
 const STATUS_ENUM = ['backlog', 'planning', 'coding', 'reviewing', 'done'];
 /** status description（LLMバイアス対策の警告文言付き） */
 const STATUS_DESCRIPTION = 'ステータス。backlog → planning → coding → reviewing → done の順で遷移。' +
-    '注意: `in_progress` / `completed` / `todo` は使用不可（Claude Code 組み込み TaskUpdate の語彙と混同しないこと）。' +
+    '注意: `in_progress` / `completed` / `todo` は使用不可（エージェント組み込みの TODO 管理ツール（Claude Code の TaskUpdate、Codex の update_plan）の語彙と混同しないこと）。' +
     '実装中 = `coding`、完了 = `done`。';
 /** typo 検出ヒント（schema validation が skip された場合のフォールバック） */
 const TYPO_HINTS = {
@@ -74,7 +74,7 @@ function createMcpServer(io) {
                             ],
                             description: 'ステータスフィルタ。単一値（例: "backlog"）または配列（例: ["backlog", "planning"]）で指定。' +
                                 '有効値: backlog / planning / coding / reviewing / done。' +
-                                '注意: `in_progress` / `completed` / `todo` は使用不可（Claude Code 組み込み TaskUpdate の語彙）。',
+                                '注意: `in_progress` / `completed` / `todo` は使用不可（エージェント組み込みの TODO 管理ツールの語彙）。',
                         },
                     },
                     additionalProperties: false,