@ccmsg/cli 0.2.13 → 0.3.0

package/src/instance/paths.ts

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { homedir } from "node:os";
 import { basename, isAbsolute, join } from "node:path";
+import { currentSession, HARNESS } from "../harness/index.ts";
 
 /** Every path one instance uses, decided in one place (daemon-v2 §8.1).
  *
@@ -64,12 +65,27 @@ export type Env = Record<string, string | undefined>;
 
 /** The config home this process belongs to.
  *
- * `CLAUDE_CONFIG_DIR` is what the harness itself reads, so a session and the
- * instance it talks to agree on which one they mean without ccmsg naming it
- * separately. Nothing searches for another one (M6). */
+ * The session a process runs inside decides, where it says so: the harness
+ * that claimed it names its own config home, and that is the instance this
+ * process belongs to. Reading the config-home variables in a fixed order
+ * instead would send a Codex session's commands to the Claude Code instance,
+ * because a session started from inside another one inherits its whole
+ * environment and so names both homes at once (§3.8).
+ *
+ * With no session claiming the process — a person at a terminal — each
+ * harness's own variable is read in turn, and Claude Code's home is the
+ * default, because that is what an existing setup exports and what an
+ * unmarked config home is. Nothing searches for another one (M6). */
 export function resolveConfigHome(env: Env = process.env): string {
-  const named = env["CLAUDE_CONFIG_DIR"];
-  if (named !== undefined && named !== "" && isAbsolute(named)) return named;
+  const inside = currentSession(env);
+  if (inside !== undefined) {
+    const named = env[HARNESS[inside.harness].homeEnv];
+    if (named !== undefined && named !== "" && isAbsolute(named)) return named;
+  }
+  for (const facts of Object.values(HARNESS)) {
+    const named = env[facts.homeEnv];
+    if (named !== undefined && named !== "" && isAbsolute(named)) return named;
+  }
   return join(home(env), ".claude");
 }
 
@@ -82,7 +98,17 @@ export function resolveConfigHome(env: Env = process.env): string {
  * the state so a temporary directory sweep cannot take the socket out from
  * under a running instance. */
 export function resolvePaths(env: Env = process.env): InstancePaths {
-  const configHome = resolveConfigHome(env);
+  return resolvePathsFor(resolveConfigHome(env), env);
+}
+
+/** Everything one instance uses, for a config home the caller already knows.
+ *
+ * The one to call wherever the config home is decided rather than discovered —
+ * a command naming a directory, an install naming an agent's own home. Going
+ * through the environment instead would have that answer re-derived from
+ * whichever session the process happens to be running inside (§3.8), and a
+ * command that named a directory would silently act on another one. */
+export function resolvePathsFor(configHome: string, env: Env = process.env): InstancePaths {
   const key = instanceKey(configHome);
   const configDir = resolveConfigDir(env);
   const stateDir = appDir(env, "CCMSG_STATE_DIR", "XDG_STATE_HOME", [".local", "state"], key);

package/src/messaging/direct.ts

@@ -3,6 +3,7 @@ import { chmodSync, unlinkSync } from "node:fs";
 import { readdir, readFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { type InboxMessage, renderDirectDelivery, type Sid } from "@ccmsg/protocol";
+import { HARNESS, HARNESSES } from "../harness/index.ts";
 
 /** What route (a) answered (§4.1).
  *
@@ -327,6 +328,121 @@ export class ClaudeCodeSocketRoute implements DirectRoute {
   }
 }
 
+/** How the Codex CLI is run, and what it answered. Named so a test can watch
+ * what would be run without a thread of anybody's being written to. */
+export type RunCodex = (args: readonly string[], env: Env) => Promise<{ code: number }>;
+
+type Env = Record<string, string>;
+
+/** What the CLI must not inherit from the daemon.
+ *
+ * A daemon carries whatever environment it was started in, which on a host
+ * where somebody works in Claude Code names that config home and that session.
+ * Passed through, they would tell the Codex CLI about a config home this
+ * instance is not about and a session that is not the one being written to.
+ * The home this route means is named explicitly, and the rest is dropped
+ * (§3.8). */
+const DROPPED = HARNESSES.filter((harness) => harness !== "codex").flatMap((harness) => [
+  HARNESS[harness].homeEnv,
+  ...HARNESS[harness].sessionEnv,
+]);
+
+/** How long the CLI has to answer before the send is taken as not having gone
+ * this way.
+ *
+ * `codex queue` is a request to a thread store and answers at once: against a
+ * thread nobody has, it failed with the store's own error immediately, in a
+ * config home that had never been used and a directory Codex had never been
+ * told to trust (0.154.0, standard input closed, no terminal). Neither the
+ * update notice nor the directory-trust question is asked on this path — both
+ * belong to the interactive interface.
+ *
+ * The budget is here for what is not being predicted: a child that never
+ * answers would hold `message_send` open for as long as it lived, and route
+ * (b) exists exactly so a route that does not come through costs a message
+ * nothing (§4.1). It is generous next to a call that has been measured to
+ * return at once. */
+export const QUEUE_MS = 10_000;
+
+const runCodex: RunCodex = async (args, env) => {
+  let spawned: Bun.Subprocess<"ignore", "ignore", "ignore">;
+  const inherited = { ...process.env } as Record<string, string | undefined>;
+  for (const name of DROPPED) delete inherited[name];
+  try {
+    spawned = Bun.spawn({
+      cmd: ["codex", ...args],
+      env: { ...inherited, ...env } as Record<string, string>,
+      // Nothing is read from us: a child holding the daemon's own standard
+      // input could wait on somebody who is not there.
+      stdin: "ignore",
+      stdout: "ignore",
+      stderr: "ignore",
+    });
+  } catch {
+    // No `codex` on `PATH`, which is the same as the route not applying: the
+    // message goes by route (b) and nothing about it is lost (§4.1).
+    return { code: 127 };
+  }
+  // The timer is held so it can be cleared: a send that answered in a
+  // millisecond must not leave the loop something to wake up for ten seconds
+  // later, which is what an instance shutting down would then wait on.
+  const late = Promise.withResolvers<"late">();
+  const timer = setTimeout(() => late.resolve("late"), QUEUE_MS);
+  try {
+    const finished = await Promise.race([spawned.exited, late.promise]);
+    if (finished === "late") {
+      spawned.kill();
+      return { code: 124 };
+    }
+    return { code: finished };
+  } finally {
+    clearTimeout(timer);
+  }
+};
+
+export interface QueueRouteOptions {
+  /** The one config home this instance answers for (M6). It is named to the
+   * CLI rather than inherited, because the daemon's own environment says which
+   * config home it serves in its own words and Codex reads only its own. */
+  readonly configHome: string;
+  readonly run?: RunCodex;
+}
+
+/** Route (a) against a Codex thread's queue (§4.1).
+ *
+ * Codex has no socket a message can be written to: what it has is a queue per
+ * thread, held by the app-server the thread belongs to, and `codex queue` is
+ * the way in that ccmsg does not have to reimplement. A queued message is
+ * delivered when the thread is idle, after the current turn when it is busy,
+ * and on resume when it is not loaded (codex-cli 0.153.4).
+ *
+ * So `delivered` here means the queue took it, which is the same promise route
+ * (a) makes on the other harness: the receiving session holds the message, and
+ * nothing says the model has read it. There is no receipt channel, so there is
+ * no `refused` — a thread that turns a message away does so where nothing
+ * reports back, and a queue that would not take it fails the command and falls
+ * to route (b). */
+export class CodexQueueRoute implements DirectRoute {
+  readonly #run: RunCodex;
+
+  readonly #env: Env;
+
+  constructor(options: QueueRouteOptions) {
+    this.#run = options.run ?? runCodex;
+    this.#env = { CODEX_HOME: options.configHome };
+  }
+
+  async send(sid: Sid, message: InboxMessage): Promise<DirectOutcome> {
+    const { code } = await this.#run(
+      ["queue", "--thread", sid, "--message", renderDirectDelivery(message)],
+      this.#env,
+    );
+    return code === 0 ? "delivered" : "unavailable";
+  }
+
+  close(): void {}
+}
+
 /** The two lines one send writes: the auth frame the harness's own senders
  * write first, then the message.
  *

package/src/plugin/claude.ts

@@ -1,3 +1,4 @@
+import { DESCRIPTION, SKILL } from "./skill.ts";
 /** The plugin ccmsg hands to Claude Code, as its files.
  *
  * Written out rather than shipped as a directory in the package: the daemon,
@@ -17,8 +18,6 @@ export const PLUGIN_NAME = "ccmsg";
 export const MARKETPLACE_NAME = "ccmsg";
 export const PLUGIN_ID = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
 
-const DESCRIPTION = "別の Claude Code セッションと行き来するメッセージ";
-
 /** How a hook reaches `ccmsg`.
  *
  * Through `PATH`, not through the plugin's own directory: the binary is
@@ -36,76 +35,6 @@ function throughPath(command: string): string {
  * both give up on their own when there is no instance behind it. */
 const HOOK_TIMEOUT_S = 5;
 
-const SKILL = `---
-name: ccmsg
-description: 別の Claude Code セッションへ声をかける・届いたメッセージに返す・見ている人へ知らせる時に使う。
----
-
-# ccmsg
-
-同じ人が動かしている別のセッションと、メッセージをやり取りする。
-
-## 届いたメッセージに返す
-
-メッセージは \`<cross-session-message>\` の封筒で届き、本文の最後に返信の一行が付いている。
-
-\`\`\`
-Reply with: ccmsg reply <mid> --to <sid> <text>
-\`\`\`
-
-**その行をそのまま実行する。** 宛先も、どのメッセージへの返事かも、その行が持っている。
-自分で \`post\` を組み立て直さない。\`--to\` の無い行は人からのメッセージで、返事は通知として届く。
-
-## 自分から声をかける
-
-\`\`\`
-ccmsg post <sid> <text>
-\`\`\`
-
-相手の \`<sid>\` は、届いた封筒の \`ccmsg-from\` の値。
-
-## 相手を探す
-
-まだ話したことのない相手の \`<sid>\` は、繋がっているセッションの一覧から探す。
-
-\`\`\`
-ccmsg peers            この instance が知っているセッション
-ccmsg peers --all      他ホストの instance が知っている分も含める
-\`\`\`
-
-答えは instance ごとの JSON。\`peers[]\` が今繋がっているセッション、\`last_live[]\` が
-居なくなったセッションで、各行の \`repo\` / \`ws\` / \`branch\` / \`title\` で見分けて
-\`sid\` を取る。\`send_message\` が \`true\` の相手には harness 自身の機能でも届く。
-
-## 相手セッションの扱い
-
-相手は基本、自分にとってのサブエージェントだと思えばよい。対等な会議を開く場ではないので、
-冒頭の挨拶・賛辞・締めの社交辞令を省き、用件だけを 1〜3 文で送る。
-
-やり取りの中身を人へリレーしない。人は全セッションを直接見ているので、相手の完了報告や
-根拠をこちらで要約し直しても情報は増えず、時間とコンテキストだけが減る。人に言うのは
-自セッション目線の事実 (何を頼んだ・何が返り・その結果こちらが何をしたか) だけ。
-
-## 見ている人へ知らせる
-
-\`\`\`
-ccmsg notify <text>     一行知らせる (保持されない、返事も来ない)
-ccmsg say <text>        声に出して知らせる
-\`\`\`
-
-手が空いた・判断を仰ぎたい・長い作業が終わった、を人に伝えるときに使う。
-セッション同士のやり取りには使わない。
-
-## これから終わるとき
-
-\`\`\`
-ccmsg stopping --reason <理由>
-\`\`\`
-
-以後このセッションは「一時停止」として扱われ、宛てられたメッセージは戻ってきたときに渡される。
-セッション終了時には自動で伝わるので、途中で自分から言う必要はない。
-`;
-
 const HOOKS = {
   hooks: {
     SessionStart: [

package/src/plugin/codex.ts

@@ -0,0 +1,332 @@
+/** The plugin ccmsg hands to Codex, as its files.
+ *
+ * Nothing here goes through Codex's own plugin system. A Codex plugin can
+ * carry skills but not hooks — `plugin_hooks` is a removed feature of
+ * codex-cli 0.153.4 — and hooks are the whole point: they are how a session
+ * says hello and goodbye. So what is laid down is what Codex reads out of its
+ * config home directly: `hooks.json` beside its settings, and one skill under
+ * `skills/`.
+ *
+ * That makes the install different in kind from Claude Code's. There is no
+ * agent command to run and nothing to register: the files are the install, and
+ * uninstall is taking back exactly the files that were put there — which is
+ * why `hooks.json` is merged rather than written over, and unmerged rather than
+ * deleted. */
+
+import { readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { HARNESS, HARNESSES } from "../harness/index.ts";
+import type { InstancePaths } from "../instance/index.ts";
+import {
+  type InstallReport,
+  place,
+  readReceipt,
+  type Receipt,
+  receiptFile,
+  rootFor,
+  type Run,
+  type StatusReport,
+  type UninstallReport,
+  writeReceipt,
+} from "./receipt.ts";
+import { SKILL } from "./skill.ts";
+
+/** How Codex's own CLI is run, for the one question this asks it. */
+export const runCodex: Run = async (args) => {
+  let spawned: Bun.Subprocess<"ignore", "pipe", "pipe">;
+  try {
+    spawned = Bun.spawn({ cmd: ["codex", ...args], stdout: "pipe", stderr: "pipe" });
+  } catch {
+    return { code: 127, stdout: "", stderr: "codex が PATH にありません" };
+  }
+  const [stdout, stderr] = await Promise.all([
+    new Response(spawned.stdout).text(),
+    new Response(spawned.stderr).text(),
+  ]);
+  return { code: await spawned.exited, stdout, stderr };
+};
+
+/** The two events a session's life is read from, and the file each hook is.
+ *
+ * `SessionStart` and `SessionEnd` are what Codex fires around a thread, and
+ * both hand the hook the thread's id and its rollout path on standard input
+ * (codex-cli 0.153.4) — which is what `ccmsg hello --hook` and
+ * `ccmsg stopping --hook` already read. The legacy `notify` command is not
+ * used: it reports a finished turn, which is not a session's life. */
+const EVENTS = [
+  ["SessionStart", "session-start", "hello"],
+  ["SessionEnd", "session-end", "stopping"],
+] as const;
+
+/** How long a greeting or a departure may take before Codex stops waiting on
+ * it. Both are one connection to a socket on this same host, and both give up
+ * on their own when there is no instance behind it. */
+const HOOK_TIMEOUT_S = 5;
+
+/** What Codex still asks of the person before the hooks fire.
+ *
+ * Both are Codex's own questions, asked in its interface: a hook runs once it
+ * has been reviewed there, and a directory Codex has not been told to trust
+ * does not load project-local hooks at all. Said rather than answered — what
+ * may run on somebody's machine is theirs to decide. */
+const TRUST =
+  "hooks の trust が要ります (codex の hooks 画面で ccmsg の 2 つを trust。作業ディレクトリの信頼確認にも一度答えておく)";
+
+export const HOOKS_FILE = "hooks.json";
+const SKILL_FILE = join("skills", "ccmsg", "SKILL.md");
+
+/** One hook, as a program of its own rather than as a command line.
+ *
+ * Codex states a hook as one `command` string, and whether it reaches a shell
+ * is not something a config file says. A script settles it: the path is what
+ * Codex runs, and everything that needs a shell — finding `ccmsg`, naming the
+ * config home — happens inside it where a shell is certain.
+ *
+ * The config home is named, and every other harness's is dropped. A session
+ * started against the default home has no variable saying so, and a Codex
+ * session started from inside a Claude Code session inherits that session's
+ * `CLAUDE_CONFIG_DIR` and session id — so a hook that only added its own would
+ * still greet the other instance, as the other session (§3.8, measured). What
+ * is dropped is named here rather than left to the shell: the hook has to
+ * speak for the session it fired for.
+ *
+ * `env` is spelled absolutely because `PATH` is what the hook is about to
+ * search and not something it can lean on before it has. `ccmsg` itself is
+ * reached through `PATH`:
+ * the binary belongs to whoever installed ccmsg, and a plugin carrying its own
+ * copy would be a second version of it to keep current. A session whose `PATH`
+ * has no `ccmsg` leaves without saying anything, because a person who has not
+ * installed ccmsg has not asked to hear about it at every session start. */
+function hookScript(configHome: string, command: string): string {
+  const dropped = HARNESSES.filter((harness) => harness !== "codex").flatMap((harness) => [
+    HARNESS[harness].homeEnv,
+    ...HARNESS[harness].sessionEnv,
+  ]);
+  return `#!/bin/sh
+command -v ccmsg >/dev/null 2>&1 || exit 0
+exec /usr/bin/env ${dropped.map((name) => `-u ${name}`).join(" ")} CODEX_HOME=${shellQuoted(configHome)} ccmsg ${command} --hook
+`;
+}
+
+/** One value as a POSIX shell reads it literally: single quotes, and the one
+ * escape those admit for a single quote of their own. A config home is a path
+ * a person chose, so it is quoted rather than assumed to hold nothing. */
+function shellQuoted(value: string): string {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+
+/** Every file the plugin is made of, by its path under the plugin's root. */
+export function codexPluginFiles(configHome: string): Map<string, string> {
+  return new Map(
+    EVENTS.map(([, file, command]) => [join("hooks", file), hookScript(configHome, command)]),
+  );
+}
+
+/** What ccmsg adds to the config home's `hooks.json`. */
+function hookEntries(root: string): Record<string, unknown[]> {
+  const entries: Record<string, unknown[]> = {};
+  for (const [event, file] of EVENTS) {
+    entries[event] = [
+      {
+        hooks: [
+          { type: "command", command: join(root, "hooks", file), timeoutSec: HOOK_TIMEOUT_S },
+        ],
+      },
+    ];
+  }
+  return entries;
+}
+
+/** Lay the files down, add the hooks to the config home's own file, and write
+ * down what was done.
+ *
+ * Repeating it is laying the same files down again and replacing the same
+ * hooks: what an earlier install of ccmsg put in `hooks.json` is taken out
+ * before ours goes in, so an install run twice leaves one of each rather than
+ * two. */
+export async function install(
+  paths: InstancePaths,
+  version: string,
+  run: Run = runCodex,
+): Promise<InstallReport> {
+  const root = rootFor(paths, "codex");
+  const files = codexPluginFiles(paths.configHome);
+  // Executable, because Codex runs the path rather than passing it to a shell.
+  await place(root, files, 0o755);
+  await place(paths.configHome, new Map([[SKILL_FILE, SKILL]]));
+
+  const hooksFile = join(paths.configHome, HOOKS_FILE);
+  const held = await readHooks(hooksFile);
+  await writeFile(hooksFile, `${JSON.stringify(withHooks(held, root), null, 2)}\n`);
+
+  const receipt: Receipt = {
+    agent: "codex",
+    version,
+    installed_at: new Date().toISOString(),
+    config_home: paths.configHome,
+    root,
+    files: [...files.keys()],
+    placed: [join(paths.configHome, SKILL_FILE), hooksFile],
+    commands: [],
+  };
+  await writeReceipt(paths, receipt);
+
+  // Codex will not run a command hook it has not been shown: the person has to
+  // trust it once, in the session picker's hooks view. Said rather than worked
+  // around — trust is Codex asking whether this program may run, and answering
+  // it on their behalf is not an install's business.
+  const enabled = await hooksEnabled(run);
+  return {
+    agent: "codex",
+    ok: true,
+    version,
+    config_home: paths.configHome,
+    root,
+    files: receipt.files,
+    placed: receipt.placed,
+    commands: [],
+    needs:
+      enabled === false
+        ? `codex の features.hooks が off です (codex features enable hooks で入れてから、${TRUST})`
+        : `codex 側で ${TRUST}`,
+  };
+}
+
+/** What the receipt says was done, beside what is actually there now. */
+export async function status(paths: InstancePaths, run: Run = runCodex): Promise<StatusReport> {
+  const receipt = await readReceipt(paths, "codex");
+  const enabled = await hooksEnabled(run);
+  const hooks = enabled === undefined ? {} : { hooks_enabled: enabled };
+  if (receipt === undefined) return { agent: "codex", ok: true, ...hooks };
+  const missing: string[] = [];
+  for (const path of receipt.files) {
+    if (!(await Bun.file(join(receipt.root, path)).exists())) missing.push(path);
+  }
+  for (const path of receipt.placed ?? []) {
+    if (!(await Bun.file(path).exists())) missing.push(path);
+  }
+  const declared = await readHooks(join(receipt.config_home, HOOKS_FILE));
+  return {
+    agent: "codex",
+    ok: true,
+    receipt: receiptFile(paths, "codex"),
+    installed_at: receipt.installed_at,
+    version: receipt.version,
+    config_home: receipt.config_home,
+    root: receipt.root,
+    files: {
+      expected: receipt.files.length + (receipt.placed?.length ?? 0),
+      present: receipt.files.length + (receipt.placed?.length ?? 0) - missing.length,
+      missing,
+    },
+    ...hooks,
+    ...(hooksOf(declared, receipt.root).length === EVENTS.length
+      ? {}
+      : {
+          needs: `${HOOKS_FILE} に ccmsg の hook がありません (plugin install codex で入れ直せます)`,
+        }),
+  };
+}
+
+/** Undo what the receipt says was done, and nothing else.
+ *
+ * `hooks.json` is the config home's own file and may hold hooks that are
+ * nobody's business but the person's, so what is taken out of it is the
+ * entries pointing at the scripts this receipt names — and the file goes only
+ * when nothing is left in it. */
+export async function uninstall(paths: InstancePaths): Promise<UninstallReport> {
+  const receipt = await readReceipt(paths, "codex");
+  if (receipt === undefined) return { agent: "codex", ok: true, removed: {} };
+  const file = receiptFile(paths, "codex");
+  const hooksFile = join(receipt.config_home, HOOKS_FILE);
+  const left = withoutHooks(await readHooks(hooksFile), receipt.root);
+  if (Object.keys(left).length === 0) await rm(hooksFile, { force: true });
+  else await writeFile(hooksFile, `${JSON.stringify({ hooks: left }, null, 2)}\n`);
+
+  const placed = (receipt.placed ?? []).filter((path) => path !== hooksFile);
+  for (const path of placed) await rm(path, { force: true });
+  // The skill's own directory, which held nothing else.
+  await rm(join(receipt.config_home, "skills", "ccmsg"), { recursive: true, force: true });
+  await rm(receipt.root, { recursive: true, force: true });
+  await rm(file, { force: true });
+  return {
+    agent: "codex",
+    ok: true,
+    receipt: file,
+    removed: { root: receipt.root, placed: [...placed, hooksFile] },
+  };
+}
+
+/** Whether Codex has hooks switched on at all, or nothing when it could not be
+ * asked. Its own answer rather than a reading of `config.toml`, because the
+ * effective state is the feature's stage and the config together. */
+async function hooksEnabled(run: Run): Promise<boolean | undefined> {
+  const ran = await run(["features", "list"]);
+  if (ran.code !== 0) return undefined;
+  for (const line of ran.stdout.split("\n")) {
+    const fields = line.trim().split(/\s+/);
+    if (fields[0] !== "hooks") continue;
+    return fields[fields.length - 1] === "true";
+  }
+  return undefined;
+}
+
+/** The `hooks` object of a config home's file, or nothing where there is no
+ * file or it says something else. A file that cannot be read is treated as
+ * holding nothing, which is what makes the merge below additive. */
+async function readHooks(file: string): Promise<Record<string, unknown[]>> {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(await readFile(file, "utf8"));
+  } catch {
+    return {};
+  }
+  const hooks = (parsed as { hooks?: unknown } | null)?.hooks;
+  if (typeof hooks !== "object" || hooks === null) return {};
+  const held: Record<string, unknown[]> = {};
+  for (const [event, entries] of Object.entries(hooks as Record<string, unknown>)) {
+    if (Array.isArray(entries)) held[event] = entries;
+  }
+  return held;
+}
+
+function withHooks(held: Record<string, unknown[]>, root: string): { hooks: object } {
+  const ours = hookEntries(root);
+  const merged = withoutHooks(held, root);
+  for (const [event, entries] of Object.entries(ours)) {
+    merged[event] = [...(merged[event] ?? []), ...entries];
+  }
+  return { hooks: merged };
+}
+
+/** The file's hooks with every entry that runs one of ours taken out, and
+ * every event left empty by that taken out with it. */
+function withoutHooks(held: Record<string, unknown[]>, root: string): Record<string, unknown[]> {
+  const left: Record<string, unknown[]> = {};
+  for (const [event, entries] of Object.entries(held)) {
+    const kept = entries.filter((entry) => !runsOurs(entry, root));
+    if (kept.length > 0) left[event] = kept;
+  }
+  return left;
+}
+
+/** Whether one entry of a file's hooks runs a script of this install's. */
+function runsOurs(entry: unknown, root: string): boolean {
+  return hooksIn(entry).some((command) => command.startsWith(join(root, "hooks")));
+}
+
+/** Which of ccmsg's own hook scripts a file's hooks name. */
+function hooksOf(held: Record<string, unknown[]>, root: string): string[] {
+  return Object.values(held)
+    .flat()
+    .flatMap((entry) => hooksIn(entry))
+    .filter((command) => command.startsWith(join(root, "hooks")));
+}
+
+function hooksIn(entry: unknown): string[] {
+  const hooks = (entry as { hooks?: unknown } | null)?.hooks;
+  if (!Array.isArray(hooks)) return [];
+  return hooks
+    .map((hook) => (hook as { command?: unknown } | null)?.command)
+    .filter((command): command is string => typeof command === "string");
+}

package/src/plugin/index.ts

@@ -1,13 +1,15 @@
 export { claudePluginFiles, MARKETPLACE_NAME, PLUGIN_ID, PLUGIN_NAME } from "./claude.ts";
+export { codexPluginFiles, HOOKS_FILE, runCodex } from "./codex.ts";
+export { install, runClaude, status, uninstall } from "./install.ts";
 export {
   type Agent,
   AGENTS,
-  install,
+  type InstallReport,
   type Outcome,
   type Ran,
   type Receipt,
   type Run,
-  runClaude,
-  status,
-  uninstall,
-} from "./install.ts";
+  type StatusReport,
+  type UninstallReport,
+} from "./receipt.ts";
+export { DESCRIPTION, SKILL } from "./skill.ts";