aiterm-mcp 0.42.1 → 0.43.0

package/CHANGELOG.md

@@ -7,6 +7,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.43.0] - 2026-09-29
+
+### 変更
+
+- 親への配送（Codexの公式キュー＋同期hook、Claude CodeのasyncRewake hook、Cursorのhook＋背景受信）の本体を、共通パッケージ[aiterm-steer-delivery](https://github.com/kitepon/aiterm-steer-delivery)へ移した。保存場所、hook command、entrypointのファイル名、案内文、配送の挙動は変わらない。旧中継（relay）はAitermに残す。他の製品（Peertable、gpt-connector）も同じパッケージで配送する。判断はrepositoryの`docs/adr/0073-parent-delivery-module.md`。
+- Codex Steerの導入で、導入前から動いているCodexを再起動待ちとして見分ける時、引用符付きのコマンド行も照合する（Windowsで見落としていた）。
+
+## [0.42.2] - 2026-09-28
+
+### 修正
+
+- Codexの利用上限を、pane logの末尾16KBに「You've hit your usage limit」があるかで判定していた。上限が明けた後の古い知らせだけでなく、道具の出力や依頼文にこの文字が入っただけでも`rate_limited`と誤判定していた（BellTeamの記録で4件）。Codexはturnが上限で終わると`task_complete`の`error`へ本文と`codex_error_info: "usage_limit_exceeded"`を書くので、完了待ちの中でこれを見て`rate_limited`を返す。`token_count`の`used_percent`は100%のまま返事が続くことがあるので使わない。判断はrepositoryの`docs/adr/0072-claude-codex-usage-limit.md`。
+
+### 変更
+
+- BellTeam向けの合間の言葉に、Codexがturnをエラーで終えた時の本文を`kind: "error"`で含める。
+
 ## [0.42.1] - 2026-09-28
 
 ### 修正
@@ -1844,7 +1861,9 @@ prototype (preserved under `prototype/python/` as the porting source and referen
   `ubuntu-latest` for Node 18/20/22, publishing to npm on `v*` tags with
   provenance.
 
-[Unreleased]: https://github.com/kitepon/aiterm-mcp/compare/v0.42.1...HEAD
+[Unreleased]: https://github.com/kitepon/aiterm-mcp/compare/v0.43.0...HEAD
+[0.43.0]: https://github.com/kitepon/aiterm-mcp/compare/v0.42.2...v0.43.0
+[0.42.2]: https://github.com/kitepon/aiterm-mcp/compare/v0.42.1...v0.42.2
 [0.42.1]: https://github.com/kitepon/aiterm-mcp/compare/v0.42.0...v0.42.1
 [0.42.0]: https://github.com/kitepon/aiterm-mcp/compare/v0.41.3...v0.42.0
 [0.41.3]: https://github.com/kitepon/aiterm-mcp/compare/v0.41.2...v0.41.3

package/README.ja.md

@@ -203,7 +203,7 @@ runtime-error store は canonical dotagents config の `collection.enabled: true
 場合だけ収集し、既定OFF、network送信は行いません。tag起点CIのnpm provenance（OIDC Trusted
 Publishing）で公開し、GitHub Release が Official MCP Registry を再登録します。
 
-**状態:** 開発継続中 · 現行公開版 **v0.42.1** · 動作対象は Linux · WSL2 · macOS · Windows ネイティブ · MIT · [変更履歴](CHANGELOG.md)。
+**状態:** 開発継続中 · 現行公開版 **v0.43.0** · 動作対象は Linux · WSL2 · macOS · Windows ネイティブ · MIT · [変更履歴](CHANGELOG.md)。
 
 ### 更新と巻き戻し
 
@@ -259,7 +259,7 @@ ClaudeがAPIエラーや安全判定の拒否で終了した時は、Stop hook
 
 Grokの無人起動は公式`--trust`で指定された作業フォルダを信頼登録し、確認画面を完了してから初回promptを送る。この登録はGrok CLIの信頼ストアへ保存され、フォルダ内のhook・MCP・LSPにも適用される。read-only sandboxの制限は維持する。画面に残る完了済みhookの結果は実行中と判定しない。
 
-Grokで終了済みターンのweekly-limitパネルが残っている場合、次の通常`pty_send`が`Shift+X`で一度閉じ、入力受付を確認して今回の本文を送る。同じsessionと会話を保ち、receiptの`pane_input_recovery`に`grok_rate_limit_dialog_dismissed`を記録する。ターン未終了・harness不在は`GROK_RATE_LIMIT_RECOVERY_BLOCKED`、解除後の入力受付失敗は`GROK_RATE_LIMIT_RECOVERY_FAILED`となり、本文は未送信。上限の継続は`rate_limited`として返し、過去promptは再送しない。Grokの上限観測には現在の画面だけを使う。
+Grokで終了済みターンのweekly-limitパネルが残っている場合、次の通常`pty_send`が`Shift+X`で一度閉じ、入力受付を確認して今回の本文を送る。同じsessionと会話を保ち、receiptの`pane_input_recovery`に`grok_rate_limit_dialog_dismissed`を記録する。ターン未終了・harness不在は`GROK_RATE_LIMIT_RECOVERY_BLOCKED`、解除後の入力受付失敗は`GROK_RATE_LIMIT_RECOVERY_FAILED`となり、本文は未送信。上限の継続は`rate_limited`として返し、過去promptは再送しない。Grokの上限観測には現在の画面だけを使う。Claude Codeの上限は現在の画面の入力欄の下に出る知らせで、Codexの上限はturnを終えた記録（`task_complete`の`codex_error_info: "usage_limit_exceeded"`）で見分ける。pane logや道具の出力に残る上限の文字では判定しない。
 
 Cursorの送信前hook（`beforeSubmitPrompt`と、互換読込するClaude Codeの`UserPromptSubmit`）がpromptを拒否すると、Cursorはpromptを捨て、turnも完了も起きない。Aitermはこの拒否の表示を見分け、起動時promptは`initial_prompt=failed`、`pty_send`は成功receiptを返さず、どちらも`USER_HOOK_BLOCKED`とhookの出力を返す。確認時間（3秒）より後の拒否は、完了待ちが`outcome=error`（`aiterm-wait`はexit 7）で返す。
 

package/README.md

@@ -217,7 +217,7 @@ collection is off by default and performs no network I/O. It ships via
 tag-triggered CI with npm provenance (OIDC Trusted Publishing); the GitHub
 Release re-registers the Official MCP Registry entry.
 
-**Status:** actively maintained · current public release **v0.42.1** · runs on Linux · WSL2 · macOS · native Windows (tmux on POSIX, the tmux-CLI-compatible [psmux](https://github.com/psmux/psmux) on native Windows — no WSL required) · MIT · see the [CHANGELOG](CHANGELOG.md).
+**Status:** actively maintained · current public release **v0.43.0** · runs on Linux · WSL2 · macOS · native Windows (tmux on POSIX, the tmux-CLI-compatible [psmux](https://github.com/psmux/psmux) on native Windows — no WSL required) · MIT · see the [CHANGELOG](CHANGELOG.md).
 
 ### Update and rollback
 
@@ -280,7 +280,7 @@ The same primitive hosts another agent's TUI. `agent_launch` starts a selected e
 
 Grokの無人起動は公式`--trust`で指定された作業フォルダを信頼登録し、確認画面を完了してから初回promptを送る。この登録はGrok CLIの信頼ストアへ保存され、フォルダ内のhook・MCP・LSPにも適用される。read-only sandboxの制限は維持する。画面に残る完了済みhookの結果は実行中と判定しない。
 
-Grokで終了済みターンのweekly-limitパネルが残っている場合、次の通常`pty_send`が`Shift+X`で一度閉じ、入力受付を確認して今回の本文を送る。同じsessionと会話を保ち、receiptの`pane_input_recovery`に`grok_rate_limit_dialog_dismissed`を記録する。ターン未終了・harness不在は`GROK_RATE_LIMIT_RECOVERY_BLOCKED`、解除後の入力受付失敗は`GROK_RATE_LIMIT_RECOVERY_FAILED`となり、本文は未送信。上限の継続は`rate_limited`として返し、過去promptは再送しない。Grokの上限観測には現在の画面だけを使う。
+Grokで終了済みターンのweekly-limitパネルが残っている場合、次の通常`pty_send`が`Shift+X`で一度閉じ、入力受付を確認して今回の本文を送る。同じsessionと会話を保ち、receiptの`pane_input_recovery`に`grok_rate_limit_dialog_dismissed`を記録する。ターン未終了・harness不在は`GROK_RATE_LIMIT_RECOVERY_BLOCKED`、解除後の入力受付失敗は`GROK_RATE_LIMIT_RECOVERY_FAILED`となり、本文は未送信。上限の継続は`rate_limited`として返し、過去promptは再送しない。Grokの上限観測には現在の画面だけを使う。Claude Codeの上限は現在の画面の入力欄の下に出る知らせで、Codexの上限はturnを終えた記録（`task_complete`の`codex_error_info: "usage_limit_exceeded"`）で見分ける。pane logや道具の出力に残る上限の文字では判定しない。
 
 When a Cursor pre-submit hook (`beforeSubmitPrompt`, or a Claude Code `UserPromptSubmit` hook that Cursor loads for compatibility) rejects the prompt, Cursor drops it and no turn or completion follows. Aiterm recognizes the rejection: an initial prompt returns `initial_prompt=failed`, and `pty_send` returns an error instead of a success receipt, both with `USER_HOOK_BLOCKED` and the hook's output. A rejection that comes after the 3-second start check is reported by the completion wait as `outcome=error` (`aiterm-wait` exit 7).
 

package/dist/claude-parent-hook.js

@@ -1,28 +1,5 @@
 #!/usr/bin/env node
-// Claude Codeが直接起動する公式hook。MCP stdioとは別processで本文をstderrへ返す。
-import { prepareClaudeHookRequest, runClaudeResultHook, closeClaudeParentSession } from "./claude-parent-receiver.js";
-async function main() {
-    let input = "";
-    process.stdin.setEncoding("utf8");
-    for await (const chunk of process.stdin)
-        input += chunk;
-    const event = JSON.parse(input);
-    switch (event.hook_event_name) {
-        case "PreToolUse":
-            prepareClaudeHookRequest(event);
-            break;
-        case "PostToolUse":
-            process.exitCode = await runClaudeResultHook(event, text => new Promise((resolve, reject) => {
-                process.stderr.write(text, error => error ? reject(error) : resolve());
-            }));
-            break;
-        case "SessionEnd":
-            closeClaudeParentSession(event);
-            break;
-        default: throw new Error("CLAUDE_PARENT_HOOK_EVENT_INVALID: 未対応のhookです");
-    }
-}
-main().catch(error => {
-    process.stderr.write(`${error instanceof Error ? error.message : "CLAUDE_PARENT_HOOK_FAILED"}\n`);
-    process.exitCode = 2;
-});
+// Claude Codeが直接起動する公式hook。MCP stdioとは別processで本文をstderrへ返す。本体はaiterm-steer-delivery。
+import { runClaudeHookMain } from "aiterm-steer-delivery";
+import { AITERM_PROFILE } from "./steer-profile.js";
+await runClaudeHookMain(AITERM_PROFILE);

package/dist/claude-parent-receiver.js

@@ -1,179 +1,27 @@
-// Claude Codeの公式hookを受信口にする。待機processはharnessが所有し、親のturnを止めない。
-import * as fs from "node:fs";
+// Claude Codeの公式hookを受信口にする。待機processはharnessが所有し、親のturnを止めない。本体はaiterm-steer-delivery。
 import * as path from "node:path";
 import { z } from "zod";
-import { ensureStateRoot, waitForFileState, writeJson0600 } from "./agent-shared.js";
-import { readRuntimeProcesses } from "./process-runtime.js";
-import { AitermError } from "./errors.js";
-const requestId = z.string().regex(/^[A-Za-z0-9_-]{1,160}$/);
-const invocationSchema = z.object({
-    request_id: requestId, session_id: z.uuid(), agent_id: z.string().nullable(),
-    parent_pid: z.number().int().positive(), parent_started_identity: z.string(),
-}).strict();
+import * as steer from "aiterm-steer-delivery";
+import { ensureStateRoot } from "./agent-shared.js";
+import { AITERM_PROFILE } from "./steer-profile.js";
+// 配送記録の検証はAitermのzodで行う（パッケージのschemaと同じ形）。
 export const claudeParentSchema = z.object({
-    kind: z.literal("claude"), request_id: requestId, session_id: z.uuid(), hook_root: z.string(),
+    kind: z.literal("claude"), request_id: z.string().regex(/^[A-Za-z0-9_-]{1,160}$/), session_id: z.uuid(), hook_root: z.string(),
 }).strict();
-export class ClaudeDeliveryError extends AitermError {
-    delivery_code;
-    outcome_unknown;
-    constructor(delivery_code, message, outcome_unknown = false) {
-        super(`${delivery_code}: ${message}`, 2);
-        this.delivery_code = delivery_code;
-        this.outcome_unknown = outcome_unknown;
-    }
-}
+export const ClaudeDeliveryError = steer.ClaudeDeliveryError;
 function defaultRoot() { return path.join(ensureStateRoot(), "claude-parent-hooks"); }
-function processIdentity(pid) { return readRuntimeProcesses().find(entry => entry.pid === pid)?.started_identity; }
-function directory(parent) { return path.join(parent.hook_root, parent.request_id); }
-function readInvocation(parent) {
-    let value;
-    try {
-        value = invocationSchema.parse(JSON.parse(fs.readFileSync(path.join(directory(parent), "request.json"), "utf8")));
-    }
-    catch {
-        throw new ClaudeDeliveryError("CLAUDE_PARENT_HOOK_UNAVAILABLE", "親のhook記録がありません。aiterm-setupを実行し、Claude Codeのhookを有効にしてください");
-    }
-    if (value.request_id !== parent.request_id || value.session_id !== parent.session_id) {
-        throw new ClaudeDeliveryError("CLAUDE_PARENT_SESSION_MISMATCH", "要求とhookの会話が一致しません");
-    }
-    return value;
-}
-function assertOpen(parent) {
-    if (fs.existsSync(path.join(directory(parent), "closed.json"))) {
-        throw new ClaudeDeliveryError("CLAUDE_PARENT_SESSION_CLOSED", "依頼元の会話は終了しました。回答を別の会話へ送っていません");
-    }
-}
-export function prepareClaudeHookRequest(input, root = defaultRoot()) {
-    const event = z.object({ session_id: z.uuid(), tool_use_id: requestId, agent_id: z.string().optional() }).parse(input);
-    const identity = processIdentity(process.ppid);
-    if (!identity)
-        throw new ClaudeDeliveryError("CLAUDE_PARENT_PROCESS_UNAVAILABLE", "hookを起動した親processを確認できません");
-    const dir = path.join(root, event.tool_use_id);
-    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-    writeJson0600(path.join(dir, "request.json"), {
-        request_id: event.tool_use_id, session_id: event.session_id, agent_id: event.agent_id ?? null,
-        parent_pid: process.ppid, parent_started_identity: identity,
-    });
-}
+export function prepareClaudeHookRequest(input, root = defaultRoot()) { steer.prepareClaudeHookRequest(input, root); }
 /** 起動時envのsession IDは/clearで古くなるため、実際のPreToolUseとの相関だけを使う。 */
 export function claudeParentFromRequest(clientName, metadata, root = defaultRoot()) {
-    if (clientName !== "claude-code")
-        return null;
-    const parsed = requestId.safeParse(metadata?.["claudecode/toolUseId"]);
-    if (!parsed.success)
-        throw new ClaudeDeliveryError("CLAUDE_PARENT_ID_UNAVAILABLE", "MCP要求にtoolUseIdがありません。対応するClaude Codeへ更新してください");
-    let invocation;
-    try {
-        invocation = invocationSchema.parse(JSON.parse(fs.readFileSync(path.join(root, parsed.data, "request.json"), "utf8")));
-    }
-    catch {
-        throw new ClaudeDeliveryError("CLAUDE_PARENT_HOOK_UNAVAILABLE", "親のPreToolUse hookを確認できません。aiterm-setupを実行し、hookを有効にしてください");
-    }
-    const parent = { kind: "claude", request_id: parsed.data, session_id: invocation.session_id, hook_root: root };
-    verifyClaudeParent(parent);
-    return parent;
-}
-export function verifyClaudeParent(parent) {
-    const invocation = readInvocation(parent);
-    if (invocation.agent_id)
-        throw new ClaudeDeliveryError("CLAUDE_PARENT_SUBAGENT_UNSUPPORTED", "agent_id付きのClaude会話（--agent起動またはnative subagent）への自動配送には対応していません");
-    assertOpen(parent);
-}
-export function bindClaudeParentDelivery(parent, deliveryId) {
-    verifyClaudeParent(parent);
-    writeJson0600(path.join(directory(parent), "delivery.json"), { delivery_id: z.uuid().parse(deliveryId) });
+    return steer.claudeParentFromRequest(AITERM_PROFILE, clientName, metadata, root);
 }
+export function verifyClaudeParent(parent) { steer.verifyClaudeParent(AITERM_PROFILE, parent); }
+export function bindClaudeParentDelivery(parent, deliveryId) { steer.bindClaudeParentDelivery(AITERM_PROFILE, parent, deliveryId); }
 /** SessionEndはその時点の依頼だけを終了する。同じ会話をresumeした新規依頼は別requestになる。 */
-export function closeClaudeParentSession(input, root = defaultRoot()) {
-    const { session_id } = z.object({ session_id: z.uuid() }).parse(input);
-    if (!fs.existsSync(root))
-        return;
-    for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
-        if (!entry.isDirectory())
-            continue;
-        const file = path.join(root, entry.name, "request.json");
-        if (!fs.existsSync(file))
-            continue;
-        const invocation = invocationSchema.parse(JSON.parse(fs.readFileSync(file, "utf8")));
-        if (invocation.session_id === session_id)
-            writeJson0600(path.join(root, entry.name, "closed.json"), { session_id });
-    }
-}
-function assertParentAlive(invocation) {
-    if (processIdentity(invocation.parent_pid) !== invocation.parent_started_identity) {
-        throw new ClaudeDeliveryError("CLAUDE_PARENT_PROCESS_CLOSED", "依頼元のClaude processは終了しました。回答は保存したままです");
-    }
-}
-export async function submitClaudeParentAnswer(parent, deliveryId, text) {
-    const invocation = readInvocation(parent);
-    const dir = directory(parent);
-    // 会話終了でも確定本文を失わない。終了判定より先に保存する。
-    writeJson0600(path.join(dir, "answer.json"), { delivery_id: deliveryId, text });
-    await waitForFileState(dir, () => {
-        const emitted = path.join(dir, "emitted.json");
-        if (fs.existsSync(emitted)) {
-            const value = JSON.parse(fs.readFileSync(emitted, "utf8"));
-            if (value.delivery_id !== deliveryId)
-                throw new ClaudeDeliveryError("CLAUDE_PARENT_DELIVERY_MISMATCH", "hookの配送IDが一致しません", true);
-            return true;
-        }
-        assertOpen(parent);
-        const failed = path.join(dir, "failed.json");
-        if (fs.existsSync(failed)) {
-            const value = JSON.parse(fs.readFileSync(failed, "utf8"));
-            throw new ClaudeDeliveryError("CLAUDE_PARENT_HOOK_FAILED", "親へのhook出力が失敗しました。回答は保存したままです", value.outcome_unknown === true);
-        }
-        const hookFile = path.join(dir, "hook.json");
-        if (fs.existsSync(hookFile)) {
-            const hook = z.object({ pid: z.number().int().positive(), started_identity: z.string() }).parse(JSON.parse(fs.readFileSync(hookFile, "utf8")));
-            if (processIdentity(hook.pid) !== hook.started_identity) {
-                throw new ClaudeDeliveryError("CLAUDE_PARENT_HOOK_CLOSED", "親の受信hookが終了しました。自動再送はしていません", fs.existsSync(path.join(dir, "sending.json")));
-            }
-        }
-        assertParentAlive(invocation);
-        return undefined;
-    });
-    return { queued_submission_id: null };
+export function closeClaudeParentSession(input, root = defaultRoot()) { steer.closeClaudeParentSession(input, root); }
+export function submitClaudeParentAnswer(parent, deliveryId, text) {
+    return steer.submitClaudeParentAnswer(AITERM_PROFILE, parent, deliveryId, text);
 }
-export async function runClaudeResultHook(input, emit, root = defaultRoot()) {
-    const event = z.object({ session_id: z.uuid(), tool_use_id: requestId }).parse(input);
-    const parent = { kind: "claude", request_id: event.tool_use_id, session_id: event.session_id, hook_root: root };
-    const invocation = readInvocation(parent);
-    const dir = directory(parent);
-    const binding = path.join(dir, "delivery.json");
-    if (!fs.existsSync(binding)) {
-        fs.rmSync(dir, { recursive: true });
-        return 0;
-    }
-    const deliveryId = z.uuid().parse(JSON.parse(fs.readFileSync(binding, "utf8")).delivery_id);
-    const identity = processIdentity(process.pid);
-    if (!identity)
-        throw new ClaudeDeliveryError("CLAUDE_PARENT_HOOK_UNAVAILABLE", "受信hookのprocessを確認できません");
-    writeJson0600(path.join(dir, "hook.json"), { pid: process.pid, started_identity: identity });
-    try {
-        const answer = await waitForFileState(dir, () => {
-            if (fs.existsSync(path.join(dir, "closed.json")))
-                return null;
-            assertParentAlive(invocation);
-            const file = path.join(dir, "answer.json");
-            if (!fs.existsSync(file))
-                return undefined;
-            const value = z.object({ delivery_id: z.uuid(), text: z.string() }).strict().parse(JSON.parse(fs.readFileSync(file, "utf8")));
-            if (value.delivery_id !== deliveryId)
-                throw new ClaudeDeliveryError("CLAUDE_PARENT_DELIVERY_MISMATCH", "保存された回答の配送IDが一致しません");
-            return value;
-        });
-        if (!answer)
-            return 0;
-        assertOpen(parent);
-        writeJson0600(path.join(dir, "sending.json"), { delivery_id: deliveryId });
-        await emit(answer.text);
-        writeJson0600(path.join(dir, "emitted.json"), { delivery_id: deliveryId });
-        // Claudeが定めるasyncRewakeの再開信号。子の成功/失敗は本文のoutcomeで区別する。
-        return 2;
-    }
-    catch (error) {
-        writeJson0600(path.join(dir, "failed.json"), { outcome_unknown: fs.existsSync(path.join(dir, "sending.json")) });
-        throw error;
-    }
+export function runClaudeResultHook(input, emit, root = defaultRoot()) {
+    return steer.runClaudeResultHook(AITERM_PROFILE, input, emit, root);
 }

package/dist/codex-delivery-error.js

@@ -1,10 +1 @@
-import { AitermError } from "./errors.js";
-export class CodexDeliveryError extends AitermError {
-    delivery_code;
-    outcome_unknown;
-    constructor(delivery_code, message, outcome_unknown = false) {
-        super(`${delivery_code}: ${message}`, 2);
-        this.delivery_code = delivery_code;
-        this.outcome_unknown = outcome_unknown;
-    }
-}
+export { CodexDeliveryError } from "aiterm-steer-delivery";

package/dist/codex-desktop-binary.js

@@ -1,27 +1,6 @@
-// Codex DesktopのSteerで使う同梱Codex CLIの場所。Desktopは更新のたびに同梱物の場所を変えることがある
-// （Windowsは版ごとのcache directory、macOSはbundle内の配置）。setup時に保存した場所が消えていたら、
-// 使う時点で公式Desktopから探し直して設定を更新する。探せなければ理由付きで失敗し、別のCodexへは切り替えない。
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { CodexDeliveryError } from "./codex-delivery-error.js";
-import { codexHookDirectory, writeHookJson } from "./codex-hook-state.js";
-async function platformFinder() {
-    if (process.platform === "win32")
-        return (await import("./windows-codex-setup.js")).findWindowsCodexBinary;
-    return (await import("./setup-codex-relay.js")).findDesktopBinary;
-}
+// Codex DesktopのSteerで使う同梱Codex CLIの場所。消えていたら使う時点で探し直す。本体はaiterm-steer-delivery。
+import * as steer from "aiterm-steer-delivery";
+import { AITERM_PROFILE } from "./steer-profile.js";
 export async function currentCodexDesktopBinary(config, options = {}) {
-    const exists = options.exists ?? fs.existsSync;
-    if (exists(config.binary))
-        return config.binary;
-    let binary;
-    try {
-        binary = (options.find ?? await platformFinder())();
-    }
-    catch (error) {
-        throw new CodexDeliveryError("CODEX_DESKTOP_BINARY_MOVED", `Codex Desktopの更新で ${config.binary} が無くなり、新しい場所も特定できません（${error instanceof Error ? error.message : String(error)}）。` +
-            "Codex Desktopを起動してから aiterm-setup --codex-steer enable を実行してください");
-    }
-    writeHookJson(path.join(options.directory ?? codexHookDirectory(), "config.json"), { ...config, binary });
-    return binary;
+    return steer.currentCodexDesktopBinary(AITERM_PROFILE, config, options);
 }

package/dist/codex-hook-state.js

@@ -1,126 +1,19 @@
-// Codexの設定領域にはhook登録だけを置き、配送の所有情報はAitermが保持する。
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { createHash, randomUUID } from "node:crypto";
-import { z } from "zod";
-import { relayConfigDirectory } from "./codex-relay-config.js";
-import { CodexDeliveryError } from "./codex-delivery-error.js";
-import { readRuntimeProcesses } from "./process-runtime.js";
-const processSchema = z.object({ pid: z.number().int(), started_identity: z.string() });
-export const codexHookConfigSchema = z.object({
-    schema: z.literal("aiterm.codex-parent-hooks.v1"), enabled: z.boolean(),
-    codex_home: z.string(), binary: z.string(), command: z.string(), node: z.string(), hook: z.string(),
-    stale_processes: z.array(processSchema),
-}).strict();
-export function codexHookDirectory() { return path.join(path.dirname(relayConfigDirectory()), "codex-parent-hooks"); }
-export function writeHookJson(file, value) {
-    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
-    const temporary = `${file}.${randomUUID()}.tmp`;
-    try {
-        fs.writeFileSync(temporary, JSON.stringify(value) + "\n", { flag: "wx", mode: 0o600 });
-        fs.renameSync(temporary, file);
-    }
-    finally {
-        if (fs.existsSync(temporary))
-            fs.unlinkSync(temporary);
-    }
-}
-export function readCodexHookConfig(directory = codexHookDirectory()) {
-    try {
-        return codexHookConfigSchema.parse(JSON.parse(fs.readFileSync(path.join(directory, "config.json"), "utf8")));
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return null;
-        throw new CodexDeliveryError("CODEX_HOOK_CONFIG_INVALID", "AitermのCodex hook設定を読めません");
-    }
-}
-export function codexInputDirectory(root, home, thread) {
-    z.uuid().parse(thread);
-    const hash = createHash("sha256").update(fs.realpathSync(home)).digest("hex");
-    return path.join(root, "inputs", hash, thread);
-}
-export const hookInputSchema = z.object({
-    delivery_id: z.uuid(), thread_id: z.uuid(), text_sha256: z.string(),
-}).strict();
-export function answerDigest(text) { return createHash("sha256").update(text).digest("hex"); }
+// Codexの設定領域にはhook登録だけを置き、配送の所有情報はAitermが保持する。本体はaiterm-steer-delivery。
+import * as steer from "aiterm-steer-delivery";
+import { AITERM_PROFILE } from "./steer-profile.js";
+export const codexHookConfigSchema = steer.codexHookConfigSchema(AITERM_PROFILE);
+export const { writeHookJson, codexInputDirectory, hookInputSchema, answerDigest } = steer;
+export function codexHookDirectory() { return steer.codexHookDirectory(AITERM_PROFILE); }
+export function readCodexHookConfig(directory = codexHookDirectory()) { return steer.readCodexHookConfig(AITERM_PROFILE, directory); }
 export function registerCodexHookInput(home, thread, id, text, root = codexHookDirectory()) {
-    const input = hookInputSchema.parse({ delivery_id: id, thread_id: thread, text_sha256: answerDigest(text) });
-    const directory = codexInputDirectory(root, home, thread);
-    fs.mkdirSync(path.join(directory, "pending"), { recursive: true, mode: 0o700 });
-    // 一つの配送IDを別の本文で再使用しない。送信前の所有記録は再送の指示にはしない。
-    fs.writeFileSync(path.join(directory, "pending", `${id}.json`), JSON.stringify(input) + "\n", { flag: "wx", mode: 0o600 });
-}
-export function finishCodexHookSubmission(home, thread, id, root) {
-    const directory = codexInputDirectory(root, home, thread);
-    const file = path.join(directory, "settled", `${id}.json`);
-    writeHookJson(file, { delivery_id: id });
-    if (!fs.existsSync(path.join(directory, "pending", `${id}.json`)))
-        fs.rmSync(file, { force: true });
+    steer.registerCodexHookInput(home, thread, id, text, root);
 }
+export function finishCodexHookSubmission(home, thread, id, root) { steer.finishCodexHookSubmission(home, thread, id, root); }
 export function codexHookDeliveryState(home, thread, id, root = codexHookDirectory()) {
-    if (!fs.existsSync(path.join(root, "inputs")))
-        return null;
-    let value;
-    try {
-        value = JSON.parse(fs.readFileSync(path.join(codexInputDirectory(root, home, thread), "claims", `${z.uuid().parse(id)}.json`), "utf8"));
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return null;
-        throw error;
-    }
-    // 所有権のlinkだけを作った段階では、公式キューからまだ削除していない。
-    if (hookInputSchema.safeParse(value).success)
-        return null;
-    if (value.state === "unknown")
-        return "unknown";
-    if (value.state === "deleting")
-        return readRuntimeProcesses().some(row => row.pid === value.pid && row.started_identity === value.started_identity) ? "sending" : "unknown";
-    if (["emitted", "not_in_queue"].includes(value.state))
-        return null;
-    throw new CodexDeliveryError("CODEX_HOOK_STATE_INVALID", "hookの配送状態を読めません");
-}
-export function ownedCodexHooks(response, command, file) {
-    const rows = response?.data;
-    if (!Array.isArray(rows) || rows.length !== 1 || !Array.isArray(rows[0]?.hooks) || rows[0]?.errors?.length) {
-        throw new CodexDeliveryError("CODEX_HOOK_UNAVAILABLE", "公式APIでCodexのhook設定を読めません");
-    }
-    const source = fs.realpathSync(file);
-    const owned = rows[0].hooks.filter((hook) => hook.command === command && hook.sourcePath === source);
-    for (const event of ["postToolUse", "stop"]) {
-        const matches = owned.filter((hook) => hook.eventName === event);
-        if (matches.length !== 1 || matches[0].async || matches[0].handlerType !== "command") {
-            throw new CodexDeliveryError("CODEX_HOOK_UNAVAILABLE", "Aitermの同期hook登録を確認できません");
-        }
-    }
-    if (owned.length !== 2)
-        throw new CodexDeliveryError("CODEX_HOOK_UNAVAILABLE", "Aitermのhook登録が重複しています");
-    return owned;
-}
-export function assertCodexHooksReady(response, command, file) {
-    if (ownedCodexHooks(response, command, file).some(hook => !hook.enabled || !["trusted", "managed"].includes(hook.trustStatus))) {
-        throw new CodexDeliveryError("CODEX_HOOK_UNTRUSTED", "AitermのCodex hookが無効または未承認です。aiterm-setupを実行してください");
-    }
+    return steer.codexHookDeliveryState(home, thread, id, root);
 }
+export function ownedCodexHooks(response, command, file) { return steer.ownedCodexHooks(AITERM_PROFILE, response, command, file); }
+export function assertCodexHooksReady(response, command, file) { steer.assertCodexHooksReady(AITERM_PROFILE, response, command, file); }
 export function assertCodexHookParentCurrent(config, rows, pid = process.pid) {
-    try {
-        fs.accessSync(config.node, fs.constants.X_OK);
-        fs.accessSync(config.hook, fs.constants.R_OK);
-    }
-    catch {
-        throw new CodexDeliveryError("CODEX_HOOK_RUNTIME_UNAVAILABLE", "Codex親hookの実行ファイルを確認できません。aiterm-setupを実行してください");
-    }
-    if (!config.stale_processes.length)
-        return;
-    const processes = new Map((rows ?? readRuntimeProcesses()).map(row => [row.pid, row]));
-    const seen = new Set();
-    let current = processes.get(pid);
-    while (current && !seen.has(current.pid)) {
-        seen.add(current.pid);
-        if (config.stale_processes.some(stale => stale.pid === current.pid && stale.started_identity === current.started_identity)) {
-            throw new CodexDeliveryError("CODEX_STEER_RESTART_REQUIRED", "親のCodexはhookの導入前から動いています。完全終了して再起動してください");
-        }
-        current = processes.get(current.parent_pid);
-    }
+    steer.assertCodexHookParentCurrent(AITERM_PROFILE, config, rows, pid);
 }

package/dist/codex-parent-hook.js

@@ -1,15 +1,5 @@
 #!/usr/bin/env node
-// stdoutはCodexの公式hook出力だけに使う。失敗をStop継続のexit 2に変換しない。
-import { runCodexResultHook } from "./codex-parent-hooks.js";
-let input = "";
-try {
-    for await (const chunk of process.stdin)
-        input += chunk;
-    await runCodexResultHook(JSON.parse(input), value => new Promise((resolve, reject) => {
-        process.stdout.write(JSON.stringify(value) + "\n", error => error ? reject(error) : resolve());
-    }), { directory: process.argv[2] });
-}
-catch (error) {
-    process.stderr.write(`CODEX_PARENT_HOOK_FAILED: ${error instanceof Error ? error.message : String(error)}\n`);
-    process.exitCode = 1;
-}
+// Codexが起動する同期hook（PostToolUse／Stop）。stdoutはCodexの公式hook出力だけに使う。本体はaiterm-steer-delivery。
+import { runCodexHookMain } from "aiterm-steer-delivery";
+import { AITERM_PROFILE } from "./steer-profile.js";
+await runCodexHookMain(AITERM_PROFILE, process.argv[2]);

package/dist/codex-parent-hooks.js

@@ -1,113 +1,6 @@
-// 親の同期hookだけが、公式キューのAiterm回答を同じターンの入力へ移す。
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { z } from "zod";
-import { realCodexHome } from "./harnesses/codex.js";
-import { withCodexReceiver } from "./codex-parent-receiver.js";
-import { CodexDeliveryError } from "./codex-delivery-error.js";
-import { readRuntimeProcesses } from "./process-runtime.js";
-import { currentCodexDesktopBinary } from "./codex-desktop-binary.js";
-import { answerDigest, codexHookDirectory, codexInputDirectory, hookInputSchema, readCodexHookConfig, writeHookJson } from "./codex-hook-state.js";
+// 親の同期hookだけが、公式キューのAiterm回答を同じターンの入力へ移す。本体はaiterm-steer-delivery。
+import * as steer from "aiterm-steer-delivery";
+import { AITERM_PROFILE } from "./steer-profile.js";
 export async function runCodexResultHook(input, emit, options = {}) {
-    const event = z.object({ session_id: z.uuid(), turn_id: z.string().min(1),
-        hook_event_name: z.enum(["PostToolUse", "Stop"]) }).parse(input);
-    const root = options.directory ?? codexHookDirectory();
-    const config = readCodexHookConfig(root);
-    if (!config?.enabled) {
-        await emit({});
-        return;
-    }
-    const home = options.codex_home ?? realCodexHome();
-    if (fs.realpathSync(home) !== fs.realpathSync(config.codex_home)) {
-        throw new CodexDeliveryError("CODEX_HOOK_HOME_MISMATCH", "hookと配送設定のCodex環境が一致しません");
-    }
-    const directory = codexInputDirectory(root, home, event.session_id);
-    const pending = path.join(directory, "pending");
-    if (!fs.existsSync(pending) || !fs.readdirSync(pending).length) {
-        await emit({});
-        return;
-    }
-    const claims = path.join(directory, "claims");
-    fs.mkdirSync(claims, { recursive: true, mode: 0o700 });
-    const taken = [];
-    const identity = readRuntimeProcesses().find(row => row.pid === process.pid);
-    if (!identity)
-        throw new CodexDeliveryError("CODEX_HOOK_PROCESS_UNAVAILABLE", "受信hookのprocessを確認できません");
-    try {
-        await withCodexReceiver({ thread_id: event.session_id, codex_home: home }, async (request) => {
-            // 削除でoffsetが動くため、全ページを読んでから取り出す。
-            const entries = [];
-            let cursor = null;
-            do {
-                const page = await request("thread/queue/list", { threadId: event.session_id, cursor, limit: 100 });
-                if (!Array.isArray(page?.data) || !(page.nextCursor === null || typeof page.nextCursor === "string")) {
-                    throw new CodexDeliveryError("CODEX_HOOK_QUEUE_INVALID", "公式キューの一覧応答を認識できません");
-                }
-                entries.push(...page.data);
-                cursor = page.nextCursor;
-            } while (cursor);
-            const queued = new Set(entries.map(entry => entry.clientUserMessageId));
-            // 送信processが終了し、キューに残っていない所有記録を消す。投入中は触らない。
-            for (const name of fs.readdirSync(pending)) {
-                const ack = path.join(directory, "settled", name);
-                if (name.endsWith(".json") && !queued.has(name.slice(0, -5)) && fs.existsSync(ack)) {
-                    fs.rmSync(path.join(pending, name), { force: true });
-                    fs.rmSync(ack, { force: true });
-                }
-            }
-            for (const entry of entries) {
-                const id = z.uuid().safeParse(entry.clientUserMessageId);
-                if (!id.success)
-                    continue;
-                const source = path.join(pending, `${id.data}.json`);
-                let owner;
-                try {
-                    owner = hookInputSchema.parse(JSON.parse(fs.readFileSync(source, "utf8")));
-                }
-                catch (error) {
-                    if (error.code === "ENOENT")
-                        continue;
-                    throw error;
-                }
-                const text = entry.input?.length === 1 && entry.input[0].type === "text" ? entry.input[0].text : undefined;
-                if (owner.delivery_id !== id.data || owner.thread_id !== event.session_id || typeof text !== "string" || answerDigest(text) !== owner.text_sha256) {
-                    throw new CodexDeliveryError("CODEX_HOOK_INPUT_CHANGED", "Aitermの配送記録とキュー本文が一致しません。取り出していません");
-                }
-                const file = path.join(claims, `${id.data}.json`);
-                // 同時hookが同じ回答を取り出すことを防ぎ、中断したclaimは自動再送しない。
-                try {
-                    fs.linkSync(source, file);
-                    fs.unlinkSync(source);
-                }
-                catch (error) {
-                    if (["ENOENT", "EEXIST"].includes(error.code ?? ""))
-                        continue;
-                    throw error;
-                }
-                fs.rmSync(path.join(directory, "settled", `${id.data}.json`), { force: true });
-                const item = { file, delivery_id: id.data, text };
-                taken.push(item);
-                writeHookJson(file, { ...owner, text, state: "deleting", turn_id: event.turn_id, queued_submission_id: entry.id,
-                    pid: identity.pid, started_identity: identity.started_identity });
-                const result = await request("thread/queue/delete", { threadId: event.session_id, queuedSubmissionId: entry.id });
-                if (typeof result?.deleted !== "boolean")
-                    throw new CodexDeliveryError("CODEX_HOOK_QUEUE_INVALID", "キュー削除の結果を確認できません", true);
-                if (!result.deleted) {
-                    writeHookJson(file, { ...owner, state: "not_in_queue", turn_id: event.turn_id });
-                    taken.pop();
-                }
-            }
-        }, options.runtime ?? { executable: await currentCodexDesktopBinary(config), timeout_ms: 5_000 });
-        const text = taken.map(item => item.text).join("\n\n");
-        await emit(!taken.length ? {} : event.hook_event_name === "Stop"
-            ? { decision: "block", reason: text }
-            : { hookSpecificOutput: { hookEventName: "PostToolUse", additionalContext: text } });
-        for (const item of taken)
-            writeHookJson(item.file, { delivery_id: item.delivery_id, state: "emitted", turn_id: event.turn_id, text: item.text });
-    }
-    catch (error) {
-        for (const item of taken)
-            writeHookJson(item.file, { delivery_id: item.delivery_id, state: "unknown", turn_id: event.turn_id, text: item.text });
-        throw error;
-    }
+    await steer.runCodexResultHook(AITERM_PROFILE, input, emit, options);
 }