@evo-dev/evodev 0.0.1-alpha → 0.0.1-alpha.10

package/dist/plugins/evodev/hooks/hooks.ts

@@ -1,16 +1,31 @@
+import type { Dirent } from "node:fs";
+import { copyFile, mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import {
+  CANONICAL_HOOK_EVENT_TYPES,
   type CanonicalHookEventType,
   type HookEventV1,
   type HookInputEventType,
   normalizeHookEvent,
 } from "@evo-dev/core";
-import { type ClaudePaths, resolveClaudePaths } from "./paths.ts";
+import {
+  type ClaudePaths,
+  type CodexPaths,
+  resolveClaudePaths,
+  resolveCodexPaths,
+} from "./paths.ts";
 
 export interface ClaudeHookInstallDryRunInput {
   homeDir: string;
   paths?: ClaudePaths;
 }
 
+export interface CodexHookInstallDryRunInput {
+  homeDir: string;
+  paths?: CodexPaths;
+}
+
 export interface ClaudeHookInstallDryRunPlan {
   target: "claude";
   settingsPath: string;
@@ -20,7 +35,27 @@ export interface ClaudeHookInstallDryRunPlan {
     reason: string;
   }>;
   warnings: string[];
-  blockers: string[];
+  advisories: string[];
+}
+
+export interface CodexHookInstallDryRunPlan {
+  target: "codex";
+  configPath: string;
+  plannedWrites: Array<{
+    action: "merge-with-backup" | "create";
+    targetPath: string;
+    reason: string;
+  }>;
+  warnings: string[];
+  advisories: string[];
+}
+
+export interface HookInstallResult {
+  target: "claude" | "codex";
+  targetPath: string;
+  backupPath: string | null;
+  changed: boolean;
+  warnings: string[];
 }
 
 export interface ClaudeHookCommand {
@@ -44,9 +79,21 @@ export interface CodexHookConfig {
 }
 
 export const CLAUDE_HOOK_RUNTIME_COMMAND =
-  'NODE_PATH="$(dirname "$(bun pm bin -g)")/install/global/node_modules${NODE_PATH:+:$NODE_PATH}" bun run "${CLAUDE_PLUGIN_ROOT}/hooks/runtime.ts" hook runtime --target claude';
-export const CODEX_HOOK_RUNTIME_COMMAND =
-  'NODE_PATH="$(dirname "$(bun pm bin -g)")/install/global/node_modules${NODE_PATH:+:$NODE_PATH}" bun run "${PLUGIN_ROOT}/hooks/runtime.ts" hook runtime --target codex';
+  'cd "${CLAUDE_PLUGIN_ROOT}" && bun run hooks/runtime.ts hook runtime --target claude';
+export const DEFAULT_CLAUDE_PLUGIN_SELECTOR = "evodev@evo-dev";
+export const CODEX_HOOK_RUNTIME_COMMAND = [
+  "sh -lc '",
+  'root="${PLUGIN_ROOT:-}"; ',
+  'if [ -z "$root" ]; then ',
+  'for candidate in "$HOME/.codex/plugins/cache/evodev/evodev"/* "$HOME/.codex/plugins/evodev"; do ',
+  'if [ -f "$candidate/hooks/runtime.ts" ]; then root="$candidate"; break; fi; ',
+  "done; ",
+  "fi; ",
+  'if [ -z "$root" ] || [ ! -f "$root/hooks/runtime.ts" ]; then exit 0; fi; ',
+  'cd "$root" && bun run hooks/runtime.ts hook runtime --target codex || exit 0',
+  "'",
+].join("");
+const CODEX_FEATURE_FLAGS = ["plugins", "plugin_hooks", "hooks"] as const;
 const CLAUDE_TOOL_EVENTS = new Set<CanonicalHookEventType>([
   "PreToolUse",
   "PermissionRequest",
@@ -94,6 +141,10 @@ const CODEX_EVENT_MATCHERS: Partial<Record<CanonicalHookEventType, string>> = {
   SubagentStop: "*",
   Stop: "*",
 };
+const RUNTIME_HOOK_EVENT_TYPES = [...CANONICAL_HOOK_EVENT_TYPES, "AgentStop"] as const;
+const RUNTIME_HOOK_EVENT_TYPE_BY_KEY = new Map<string, HookInputEventType>(
+  RUNTIME_HOOK_EVENT_TYPES.map((type) => [normalizeRuntimeHookEventName(type), type]),
+);
 
 export function planClaudeHookInstallDryRun(
   input: ClaudeHookInstallDryRunInput,
@@ -107,17 +158,195 @@ export function planClaudeHookInstallDryRun(
         action: "merge-with-backup",
         targetPath: paths.settingsPath,
         reason:
-          "dry-run only: would add disabled EvoDev user-level hooks after future confirmation; no file is written",
+          "would reconcile EvoDev-managed user-level hook entries with Claude plugin ownership without touching user-owned hooks",
       },
     ],
-    warnings: [
-      "Hooks remain disabled by default.",
-      "Project .claude, .codex, CLAUDE.md, and AGENTS.md are never targeted by this dry-run.",
+    warnings: ["Project .claude, .codex, CLAUDE.md, and AGENTS.md are not targeted."],
+    advisories: [],
+  };
+}
+
+export function planCodexHookInstallDryRun(
+  input: CodexHookInstallDryRunInput,
+): CodexHookInstallDryRunPlan {
+  const paths = input.paths ?? resolveCodexPaths({ homeDir: input.homeDir });
+  return {
+    target: "codex",
+    configPath: paths.configPath,
+    plannedWrites: [
+      {
+        action: "merge-with-backup",
+        targetPath: paths.configPath,
+        reason:
+          "would enable missing Codex plugin hook feature flags while preserving explicit user-owned false values",
+      },
     ],
-    blockers: [],
+    warnings: ["Codex hook definitions are supplied by the EvoDev Codex plugin manifest."],
+    advisories: [],
   };
 }
 
+export async function installClaudeHooks(input: {
+  homeDir: string;
+  paths?: ClaudePaths;
+  now?: string;
+  pluginSelector?: string;
+  pluginManaged?: boolean;
+}): Promise<HookInstallResult> {
+  const paths = input.paths ?? resolveClaudePaths({ homeDir: input.homeDir });
+  const existing = await readTextIfExists(paths.settingsPath);
+  const pluginSelector = input.pluginSelector ?? DEFAULT_CLAUDE_PLUGIN_SELECTOR;
+  if (input.pluginManaged === true || isClaudePluginEnabled(existing, pluginSelector)) {
+    const next = removeClaudeManagedUserHooks(existing);
+    if (next === null) {
+      return {
+        target: "claude",
+        targetPath: paths.settingsPath,
+        backupPath: null,
+        changed: false,
+        warnings: [],
+      };
+    }
+    return writeMergedConfig({
+      target: "claude",
+      path: paths.settingsPath,
+      existing,
+      next,
+      now: input.now,
+      warnings: [],
+    });
+  }
+  const runtimeCommand = await resolveClaudeUserHookRuntimeCommand({
+    paths,
+    pluginSelector,
+  });
+  const next = mergeClaudeSettingsHooks(existing, createClaudeHookConfig(runtimeCommand).hooks);
+  return writeMergedConfig({
+    target: "claude",
+    path: paths.settingsPath,
+    existing,
+    next,
+    now: input.now,
+    warnings: [],
+  });
+}
+
+async function resolveClaudeUserHookRuntimeCommand(input: {
+  paths: ClaudePaths;
+  pluginSelector: string;
+}): Promise<string> {
+  const runtimePath =
+    (await resolveInstalledClaudePluginRuntimePath(input)) ?? (await resolveLocalRuntimePath());
+  const pluginRoot = dirname(dirname(runtimePath));
+  return `cd ${shellQuote(pluginRoot)} && bun run hooks/runtime.ts hook runtime --target claude`;
+}
+
+async function resolveInstalledClaudePluginRuntimePath(input: {
+  paths: ClaudePaths;
+  pluginSelector: string;
+}): Promise<string | null> {
+  const marketplaceName = extractMarketplaceNameFromSelector(input.pluginSelector);
+  const pluginName = extractPluginNameFromSelector(input.pluginSelector);
+  if (marketplaceName === null || pluginName === null) return null;
+  if (!isSafePluginCacheSegment(marketplaceName) || !isSafePluginCacheSegment(pluginName)) {
+    return null;
+  }
+
+  const cacheRoot = join(input.paths.claudeDir, "plugins", "cache", marketplaceName, pluginName);
+  let entries: Dirent[];
+  try {
+    entries = await readdir(cacheRoot, { withFileTypes: true });
+  } catch (error) {
+    if (isNotFoundError(error)) return null;
+    throw error;
+  }
+
+  const candidates = (
+    await Promise.all(
+      entries
+        .filter((entry) => entry.isDirectory())
+        .map(async (entry) => {
+          const runtimePath = join(cacheRoot, entry.name, "hooks", "runtime.ts");
+          try {
+            const runtimeStat = await stat(runtimePath);
+            return runtimeStat.isFile()
+              ? { path: runtimePath, mtimeMs: runtimeStat.mtimeMs }
+              : null;
+          } catch (error) {
+            if (isNotFoundError(error)) return null;
+            throw error;
+          }
+        }),
+    )
+  ).filter((candidate): candidate is { path: string; mtimeMs: number } => candidate !== null);
+
+  if (candidates.length === 0) return null;
+  candidates.sort(
+    (left, right) => right.mtimeMs - left.mtimeMs || right.path.localeCompare(left.path),
+  );
+  return candidates[0].path;
+}
+
+function extractMarketplaceNameFromSelector(selector: string): string | null {
+  const separator = selector.lastIndexOf("@");
+  if (separator <= 0 || separator === selector.length - 1) return null;
+  const marketplaceName = selector.slice(separator + 1).trim();
+  return marketplaceName === "" ? null : marketplaceName;
+}
+
+function extractPluginNameFromSelector(selector: string): string | null {
+  const separator = selector.lastIndexOf("@");
+  const pluginName = (separator <= 0 ? selector : selector.slice(0, separator)).trim();
+  return pluginName === "" ? null : pluginName;
+}
+
+function isSafePluginCacheSegment(segment: string): boolean {
+  return /^[A-Za-z0-9._-]+$/.test(segment) && segment !== "." && segment !== "..";
+}
+
+async function resolveLocalRuntimePath(): Promise<string> {
+  const currentDir = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    join(currentDir, "runtime.ts"),
+    join(currentDir, "plugins", "evodev", "hooks", "runtime.ts"),
+  ];
+
+  for (const candidate of candidates) {
+    try {
+      const candidateStat = await stat(candidate);
+      if (candidateStat.isFile()) return candidate;
+    } catch (error) {
+      if (isNotFoundError(error)) continue;
+      throw error;
+    }
+  }
+
+  throw new Error(
+    `Cannot resolve Claude user-level hook runtime path. Checked: ${candidates.join(", ")}`,
+  );
+}
+
+export async function installCodexHooks(input: {
+  homeDir: string;
+  paths?: CodexPaths;
+  now?: string;
+}): Promise<HookInstallResult> {
+  const paths = input.paths ?? resolveCodexPaths({ homeDir: input.homeDir });
+  const existing = await readTextIfExists(paths.configPath);
+  const merged = mergeCodexFeatureFlags(existing);
+  return writeMergedConfig({
+    target: "codex",
+    path: paths.configPath,
+    existing,
+    next: merged.content,
+    now: input.now,
+    warnings: [
+      "Codex hook definitions are loaded from the installed EvoDev Codex plugin.",
+      ...merged.warnings,
+    ],
+  });
+}
+
 export function normalizeClaudeHookPayload(input: {
   type: HookInputEventType;
   payload: Record<string, unknown>;
@@ -136,12 +365,11 @@ export function normalizeClaudeRuntimeHookPayload(input: {
   payload: Record<string, unknown>;
   receivedAt?: string;
 }): HookEventV1 {
-  const type = input.payload.hook_event_name ?? input.payload.hookEventName;
-  if (typeof type !== "string" || type.trim() === "") {
-    throw new Error("Claude hook payload is missing hook_event_name.");
-  }
   return normalizeClaudeHookPayload({
-    type: type as HookInputEventType,
+    type: readRuntimeHookEventType(
+      input.payload.hook_event_name ?? input.payload.hookEventName,
+      "Claude",
+    ),
     payload: input.payload,
     receivedAt: input.receivedAt,
   });
@@ -165,21 +393,34 @@ export function normalizeCodexRuntimeHookPayload(input: {
   payload: Record<string, unknown>;
   receivedAt?: string;
 }): HookEventV1 {
-  const type =
-    input.payload.hook_event_name ??
-    input.payload.hookEventName ??
-    input.payload.event ??
-    input.payload.name;
-  if (typeof type !== "string" || type.trim() === "") {
-    throw new Error("Codex hook payload is missing hook_event_name.");
-  }
   return normalizeCodexHookPayload({
-    type: type as HookInputEventType,
+    type: readRuntimeHookEventType(
+      input.payload.hook_event_name ??
+        input.payload.hookEventName ??
+        input.payload.event ??
+        input.payload.name,
+      "Codex",
+    ),
     payload: input.payload,
     receivedAt: input.receivedAt,
   });
 }
 
+function readRuntimeHookEventType(value: unknown, target: "Claude" | "Codex"): HookInputEventType {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`${target} hook payload is missing hook_event_name.`);
+  }
+  const normalized = RUNTIME_HOOK_EVENT_TYPE_BY_KEY.get(normalizeRuntimeHookEventName(value));
+  if (normalized === undefined) {
+    throw new Error(`Unsupported hook event type: ${value}`);
+  }
+  return normalized;
+}
+
+function normalizeRuntimeHookEventName(value: string): string {
+  return value.replace(/[^A-Za-z0-9]/g, "").toLowerCase();
+}
+
 export function createClaudeHookConfig(
   command: string = CLAUDE_HOOK_RUNTIME_COMMAND,
 ): ClaudeHookConfig {
@@ -194,7 +435,7 @@ export function createClaudeHookConfig(
   }
   return {
     description:
-      "EvoDev routes Claude Code lifecycle events through evodev hook runtime for Task Contract, workflow, policy, and evidence control.",
+      "EvoDev observes Claude Code lifecycle events through evodev hook runtime for local trace and action-required advisories.",
     hooks,
   };
 }
@@ -215,3 +456,207 @@ export function createCodexHookConfig(
   }
   return { hooks };
 }
+
+async function readTextIfExists(path: string): Promise<string | null> {
+  try {
+    return await readFile(path, "utf8");
+  } catch (error) {
+    if (isNotFoundError(error)) return null;
+    throw error;
+  }
+}
+
+async function writeMergedConfig(input: {
+  target: "claude" | "codex";
+  path: string;
+  existing: string | null;
+  next: string;
+  now?: string;
+  warnings: string[];
+}): Promise<HookInstallResult> {
+  if (input.existing === input.next) {
+    return {
+      target: input.target,
+      targetPath: input.path,
+      backupPath: null,
+      changed: false,
+      warnings: input.warnings,
+    };
+  }
+
+  await mkdir(dirname(input.path), { recursive: true });
+  let backupPath: string | null = null;
+  if (input.existing !== null && (await fileExists(input.path))) {
+    backupPath = `${input.path}.evodev-${backupTimestamp(input.now)}.bak`;
+    await copyFile(input.path, backupPath);
+  }
+  await writeFile(input.path, input.next, "utf8");
+  return {
+    target: input.target,
+    targetPath: input.path,
+    backupPath,
+    changed: true,
+    warnings: input.warnings,
+  };
+}
+
+function mergeClaudeSettingsHooks(
+  existing: string | null,
+  evodevHooks: ClaudeHookConfig["hooks"],
+): string {
+  const settings = parseJsonConfig(existing, "Claude settings");
+  const currentHooks = isRecord(settings.hooks) ? settings.hooks : {};
+  const nextHooks: Record<string, unknown> = { ...currentHooks };
+
+  for (const [eventName, groups] of Object.entries(evodevHooks)) {
+    const existingGroups = Array.isArray(currentHooks[eventName]) ? currentHooks[eventName] : [];
+    nextHooks[eventName] = [
+      ...existingGroups.filter((group) => !isEvoDevHookGroup(group, "claude")),
+      ...(groups ?? []),
+    ];
+  }
+
+  return `${JSON.stringify({ ...settings, hooks: nextHooks }, null, 2)}\n`;
+}
+
+function isClaudePluginEnabled(existing: string | null, pluginSelector: string): boolean {
+  if (existing === null) return false;
+  const settings = parseJsonConfig(existing, "Claude settings");
+  const enabledPlugins = isRecord(settings.enabledPlugins) ? settings.enabledPlugins : {};
+  return enabledPlugins[pluginSelector] === true;
+}
+
+function removeClaudeManagedUserHooks(existing: string | null): string | null {
+  if (existing === null) return null;
+  const settings = parseJsonConfig(existing, "Claude settings");
+  if (!isRecord(settings.hooks)) return existing;
+
+  const nextHooks: Record<string, unknown> = {};
+  let changed = false;
+  for (const [eventName, groups] of Object.entries(settings.hooks)) {
+    if (!Array.isArray(groups)) {
+      nextHooks[eventName] = groups;
+      continue;
+    }
+    const retained = groups.filter((group) => !isEvoDevHookGroup(group, "claude"));
+    changed ||= retained.length !== groups.length;
+    if (retained.length > 0 || groups.length === 0) nextHooks[eventName] = retained;
+  }
+  if (!changed) return existing;
+
+  const nextSettings = { ...settings };
+  if (Object.keys(nextHooks).length === 0) nextSettings.hooks = undefined;
+  else nextSettings.hooks = nextHooks;
+  return `${JSON.stringify(nextSettings, null, 2)}\n`;
+}
+
+function parseJsonConfig(existing: string | null, label: string): Record<string, unknown> {
+  if (existing === null || existing.trim() === "") return {};
+  const parsed = JSON.parse(existing) as unknown;
+  if (!isRecord(parsed)) throw new Error(`${label} must be a JSON object.`);
+  return parsed;
+}
+
+function isEvoDevHookGroup(group: unknown, target: "claude" | "codex"): boolean {
+  if (!isRecord(group) || !Array.isArray(group.hooks)) return false;
+  return group.hooks.some((hook) => {
+    if (!isRecord(hook) || typeof hook.command !== "string") return false;
+    return hook.command.includes(`hook runtime --target ${target}`);
+  });
+}
+
+function mergeCodexFeatureFlags(existing: string | null): { content: string; warnings: string[] } {
+  const source = existing ?? "";
+  const lines = source === "" ? [] : source.replace(/\n$/, "").split("\n");
+  const section = findTomlSection(lines, "features");
+  if (section === null) {
+    const prefix = lines.length === 0 ? [] : [...lines, ""];
+    return {
+      content: [
+        ...prefix,
+        "[features]",
+        ...CODEX_FEATURE_FLAGS.map((flag) => `${flag} = true`),
+        "",
+      ].join("\n"),
+      warnings: [],
+    };
+  }
+
+  const nextLines = [...lines];
+  const seen = new Set<string>();
+  const preservedFalseFlags: string[] = [];
+  for (let index = section.start + 1; index < section.end; index += 1) {
+    const match = nextLines[index]?.match(/^(\s*)([A-Za-z0-9_-]+)(\s*=\s*)(.*)$/);
+    if (match === null) continue;
+    const key = match[2];
+    if ((CODEX_FEATURE_FLAGS as readonly string[]).includes(key)) {
+      seen.add(key);
+      if (isTomlBooleanFalse(match[4])) {
+        preservedFalseFlags.push(key);
+      } else {
+        nextLines[index] = `${match[1]}${key}${match[3]}true`;
+      }
+    }
+  }
+
+  const missing = CODEX_FEATURE_FLAGS.filter((flag) => !seen.has(flag));
+  nextLines.splice(section.end, 0, ...missing.map((flag) => `${flag} = true`));
+  return {
+    content: `${nextLines.join("\n")}\n`,
+    warnings:
+      preservedFalseFlags.length === 0
+        ? []
+        : [
+            `Explicitly disabled Codex feature flags were preserved: ${preservedFalseFlags.join(", ")}.`,
+          ],
+  };
+}
+
+function isTomlBooleanFalse(value: string): boolean {
+  return /^false(?:\s*(?:#.*)?)?$/i.test(value.trim());
+}
+
+function findTomlSection(lines: string[], name: string): { start: number; end: number } | null {
+  const header = `[${name}]`;
+  const start = lines.findIndex((line) => line.trim() === header);
+  if (start < 0) return null;
+  let end = lines.length;
+  for (let index = start + 1; index < lines.length; index += 1) {
+    if (/^\s*\[[^\]]+\]\s*$/.test(lines[index] ?? "")) {
+      end = index;
+      break;
+    }
+  }
+  return { start, end };
+}
+
+function backupTimestamp(value?: string): string {
+  const source = value ?? new Date().toISOString();
+  return source.replace(/[^0-9A-Za-z]/g, "").slice(0, 20) || "now";
+}
+
+function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+
+async function fileExists(path: string): Promise<boolean> {
+  try {
+    return (await stat(path)).isFile();
+  } catch (error) {
+    if (isNotFoundError(error)) return false;
+    throw error;
+  }
+}
+
+function isNotFoundError(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "code" in error &&
+    (error as { code?: unknown }).code === "ENOENT"
+  );
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/plugins/evodev/hooks/index.ts

@@ -2,15 +2,21 @@ export {
   type CodexCommandResult,
   type CodexCommandRunner,
   type CodexPluginOptions,
+  type CodexSyncFileSystem,
   codexPlugin,
   createCodexPlugin,
 } from "./codex.ts";
 
 export { type ClaudeCommandResult, type ClaudeCommandRunner, detectClaudeCode } from "./detect.ts";
 export {
+  type CodexPaths,
+  type ResolveCodexPathsOptions,
   type ClaudePaths,
   type ResolveClaudePathsOptions,
+  assertSafeCodexAssetName,
   assertSafeClaudeAssetName,
+  resolveCodexAgentTargetPath,
+  resolveCodexPaths,
   resolveClaudeAgentTargetPath,
   resolveClaudePaths,
   resolveClaudeSkillTargetPath,
@@ -23,13 +29,19 @@ export {
   type ClaudeHookInstallDryRunInput,
   type ClaudeHookInstallDryRunPlan,
   type ClaudeHookMatcherGroup,
+  type CodexHookInstallDryRunInput,
+  type CodexHookInstallDryRunPlan,
   type CodexHookConfig,
+  type HookInstallResult,
   createCodexHookConfig,
   createClaudeHookConfig,
+  installClaudeHooks,
+  installCodexHooks,
   normalizeCodexHookPayload,
   normalizeCodexRuntimeHookPayload,
   normalizeClaudeHookPayload,
   normalizeClaudeRuntimeHookPayload,
+  planCodexHookInstallDryRun,
   planClaudeHookInstallDryRun,
 } from "./hooks.ts";
 export {
@@ -43,6 +55,9 @@ export {
 export {
   type ClaudeAgentTransformInput,
   type ClaudeAgentTransformResult,
+  type CodexAgentTransformInput,
+  type CodexAgentTransformResult,
+  transformCodexAgent,
   transformClaudeAgent,
 } from "./transform-agent.ts";
 export {

package/dist/plugins/evodev/hooks/paths.ts

@@ -6,11 +6,24 @@ export interface ClaudePaths {
   agentsDir: string;
 }
 
+export interface CodexPaths {
+  homeDir: string;
+  codexDir: string;
+  configPath: string;
+  hooksPath: string;
+  agentsDir: string;
+}
+
 export interface ResolveClaudePathsOptions {
   homeDir: string;
   claudeDir?: string;
 }
 
+export interface ResolveCodexPathsOptions {
+  homeDir: string;
+  codexDir?: string;
+}
+
 export function resolveClaudePaths(options: ResolveClaudePathsOptions): ClaudePaths {
   const homeDir = stripTrailingSlash(options.homeDir);
   const claudeDir = stripTrailingSlash(options.claudeDir ?? `${homeDir}/.claude`);
@@ -24,6 +37,19 @@ export function resolveClaudePaths(options: ResolveClaudePathsOptions): ClaudePa
   };
 }
 
+export function resolveCodexPaths(options: ResolveCodexPathsOptions): CodexPaths {
+  const homeDir = stripTrailingSlash(options.homeDir);
+  const codexDir = stripTrailingSlash(options.codexDir ?? `${homeDir}/.codex`);
+
+  return {
+    homeDir,
+    codexDir,
+    configPath: `${codexDir}/config.toml`,
+    hooksPath: `${codexDir}/hooks.json`,
+    agentsDir: `${codexDir}/agents`,
+  };
+}
+
 export function resolveClaudeSkillTargetPath(skillName: string, paths: ClaudePaths): string {
   const safeSkillName = assertSafeClaudeAssetName(skillName, "skillName");
   return `${paths.skillsDir}/${safeSkillName}/SKILL.md`;
@@ -34,10 +60,27 @@ export function resolveClaudeAgentTargetPath(agentName: string, paths: ClaudePat
   return `${paths.agentsDir}/${safeAgentName}.md`;
 }
 
+export function resolveCodexAgentTargetPath(agentName: string, paths: CodexPaths): string {
+  const safeAgentName = assertSafeCodexAssetName(agentName, "agentName");
+  return `${paths.agentsDir}/${safeAgentName}.toml`;
+}
+
 export function assertSafeClaudeAssetName(name: string, label = "name"): string {
+  return assertSafeCodeAgentAssetName(name, "Claude", label);
+}
+
+export function assertSafeCodexAssetName(name: string, label = "name"): string {
+  return assertSafeCodeAgentAssetName(name, "Codex", label);
+}
+
+function assertSafeCodeAgentAssetName(
+  name: string,
+  target: "Claude" | "Codex",
+  label: string,
+): string {
   if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(name) || name === "." || name === "..") {
     throw new Error(
-      `Invalid Claude asset ${label}: must be a single safe path segment using letters, numbers, dot, underscore, or hyphen`,
+      `Invalid ${target} asset ${label}: must be a single safe path segment using letters, numbers, dot, underscore, or hyphen`,
     );
   }