@evo-dev/evodev 0.0.1-alpha.1 → 0.0.1-alpha.2

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

@@ -1,6 +1,9 @@
-import { copyFile, mkdir, readFile, stat, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
+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,
@@ -76,9 +79,20 @@ export interface CodexHookConfig {
 }
 
 export const CLAUDE_HOOK_RUNTIME_COMMAND =
-  'bun run "${CLAUDE_PLUGIN_ROOT}/hooks/runtime.ts" hook runtime --target claude';
-export const CODEX_HOOK_RUNTIME_COMMAND =
-  '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",
@@ -127,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,
@@ -172,10 +190,15 @@ export async function installClaudeHooks(input: {
   homeDir: string;
   paths?: ClaudePaths;
   now?: string;
+  pluginSelector?: string;
 }): Promise<HookInstallResult> {
   const paths = input.paths ?? resolveClaudePaths({ homeDir: input.homeDir });
   const existing = await readTextIfExists(paths.settingsPath);
-  const next = mergeClaudeSettingsHooks(existing, createClaudeHookConfig().hooks);
+  const runtimeCommand = await resolveClaudeUserHookRuntimeCommand({
+    paths,
+    pluginSelector: input.pluginSelector ?? DEFAULT_CLAUDE_PLUGIN_SELECTOR,
+  });
+  const next = mergeClaudeSettingsHooks(existing, createClaudeHookConfig(runtimeCommand).hooks);
   return writeMergedConfig({
     target: "claude",
     path: paths.settingsPath,
@@ -186,6 +209,101 @@ export async function installClaudeHooks(input: {
   });
 }
 
+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;
@@ -225,12 +343,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,
   });
@@ -254,21 +371,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 {
@@ -283,7 +413,7 @@ export function createClaudeHookConfig(
   }
   return {
     description:
-      "EvoDev observes Claude Code lifecycle events through evodev hook runtime for local trace and advisory workflow suggestions.",
+      "EvoDev observes Claude Code lifecycle events through evodev hook runtime for local trace and action-required advisories.",
     hooks,
   };
 }
@@ -452,6 +582,10 @@ function backupTimestamp(value?: string): string {
   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();

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

@@ -1,22 +1,20 @@
 #!/usr/bin/env bun
 
-import {
-  type HookEventV1,
-  type HookRuntimeResult,
-  appendTraceLogEntry,
-  createCoreConfigStore,
-  createDefaultSettings,
-  createTraceLogEntry,
-  formatHookRuntimeOutput,
-  handleHookRuntime,
-  resolveTraceTeamContext,
-} from "@evo-dev/core";
-import { normalizeClaudeRuntimeHookPayload, normalizeCodexRuntimeHookPayload } from "./hooks.ts";
+import type { HookEventV1, HookRuntimeResult } from "@evo-dev/core";
+
+export type HookRuntimeCoreApi = typeof import("@evo-dev/core");
+export type HookRuntimeNormalizerApi = typeof import("./hooks.ts");
+
+export interface HookRuntimeApi {
+  core: HookRuntimeCoreApi;
+  normalizers: HookRuntimeNormalizerApi;
+}
 
 export interface HookRuntimeCliOptions {
   argv?: string[];
   environment?: Record<string, string | undefined>;
   homeDir?: string;
+  loadRuntimeApi?: () => Promise<HookRuntimeApi>;
   stdin?: string | (() => Promise<string>);
   write?: (message: string) => void;
 }
@@ -26,7 +24,9 @@ export async function runHookRuntimeCli(options: HookRuntimeCliOptions = {}): Pr
   const environment = options.environment ?? process.env;
   const write = options.write ?? process.stdout.write.bind(process.stdout);
   const startedAt = new Date();
+  const loadRuntimeApi = options.loadRuntimeApi ?? loadDefaultHookRuntimeApi;
   let homeDir = options.homeDir ?? process.env.HOME ?? "~";
+  let runtimeApi: HookRuntimeApi | null = null;
   let target = "unknown";
   let payload: Record<string, unknown> | null = null;
   let stdinBytes: number | null = null;
@@ -45,8 +45,10 @@ export async function runHookRuntimeCli(options: HookRuntimeCliOptions = {}): Pr
     homeDir = options.homeDir ?? process.env.HOME ?? "~";
     const stdin = await readHookRuntimeStdin(options.stdin);
     stdinBytes = Buffer.byteLength(stdin, "utf8");
+    runtimeApi = await loadRuntimeApi();
     payload = JSON.parse(stdin) as Record<string, unknown>;
-    await appendTraceLogSafely({
+    await appendExecutionEventSafely({
+      core: runtimeApi.core,
       homeDir,
       phase: "started",
       target,
@@ -56,28 +58,31 @@ export async function runHookRuntimeCli(options: HookRuntimeCliOptions = {}): Pr
       environment,
     });
 
-    const settings = await readHookSettings(homeDir);
+    const settings = await readHookSettings(runtimeApi.core, homeDir);
     const event =
       flags.target === "codex"
-        ? normalizeCodexRuntimeHookPayload({
+        ? runtimeApi.normalizers.normalizeCodexRuntimeHookPayload({
             payload,
             receivedAt: new Date().toISOString(),
           })
-        : normalizeClaudeRuntimeHookPayload({
+        : runtimeApi.normalizers.normalizeClaudeRuntimeHookPayload({
             payload,
             receivedAt: new Date().toISOString(),
           });
-    const result = await handleHookRuntime({
+    const result = await runtimeApi.core.handleHookRuntime({
       target: flags.target,
       homeDir,
       settings: settings.hooks,
+      teamRuntimeDisplayMode: settings.teamRuntime.displayMode,
       event,
       rawPayload: payload,
       receivedAt: event.time.receivedAt,
       environment,
+      runtimeInjectionEnabled: settings.memory.runtimeInjection,
     });
-    const formatted = formatHookRuntimeOutput(result);
-    await appendTraceLogSafely({
+    const formatted = runtimeApi.core.formatHookRuntimeOutput(result);
+    await appendExecutionEventSafely({
+      core: runtimeApi.core,
       homeDir,
       phase: "completed",
       target,
@@ -86,14 +91,14 @@ export async function runHookRuntimeCli(options: HookRuntimeCliOptions = {}): Pr
       stdinBytes,
       event,
       result,
-      formatted,
       environment,
       durationMs: Date.now() - startedAt.getTime(),
     });
     if (formatted.length > 0) write(formatted);
     return 0;
   } catch (error) {
-    await appendTraceLogSafely({
+    await appendExecutionEventSafely({
+      core: runtimeApi?.core,
       homeDir,
       phase: "failed",
       target,
@@ -104,10 +109,15 @@ export async function runHookRuntimeCli(options: HookRuntimeCliOptions = {}): Pr
       environment,
       durationMs: Date.now() - startedAt.getTime(),
     });
-    throw error;
+    return 0;
   }
 }
 
+async function loadDefaultHookRuntimeApi(): Promise<HookRuntimeApi> {
+  const [core, normalizers] = await Promise.all([import("@evo-dev/core"), import("./hooks.ts")]);
+  return { core, normalizers };
+}
+
 function parseHookRuntimeFlags(argv: string[]): { target: string } {
   let target: string | undefined;
   for (let index = 0; index < argv.length; index += 1) {
@@ -138,18 +148,19 @@ async function readHookRuntimeStdin(stdin: HookRuntimeCliOptions["stdin"]): Prom
   return Buffer.concat(chunks).toString("utf8");
 }
 
-async function readHookSettings(homeDir: string) {
+async function readHookSettings(core: HookRuntimeCoreApi, homeDir: string) {
   try {
-    return await createCoreConfigStore(homeDir).readSettings();
+    return await core.createCoreConfigStore(homeDir).readSettings();
   } catch (error) {
     if (isNotFoundError(error)) {
-      return createDefaultSettings();
+      return core.createDefaultSettings();
     }
-    throw error;
+    return core.createDefaultSettings();
   }
 }
 
-async function appendTraceLogSafely(input: {
+async function appendExecutionEventSafely(input: {
+  core?: HookRuntimeCoreApi;
   homeDir: string;
   phase: "started" | "completed" | "failed";
   target: string;
@@ -158,56 +169,115 @@ async function appendTraceLogSafely(input: {
   stdinBytes: number | null;
   event?: HookEventV1;
   result?: HookRuntimeResult;
-  formatted?: string;
   durationMs?: number | null;
   error?: unknown;
   environment?: Record<string, string | undefined>;
 }): Promise<void> {
+  if (input.core === undefined) return;
+
   try {
-    await appendTraceLogEntry(
+    const sessionKey =
+      input.payload === null ? "session-local" : input.core.resolveTraceSessionKey(input.payload);
+    const team = input.core.resolveTraceTeamContext({
+      homeDir: input.homeDir,
+      environment: input.environment,
+      payload: input.payload,
+    });
+    const traceRefId = await recordTraceRefSafely(input);
+    await input.core.appendEvoDevExecutionEvent(
       input.homeDir,
-      createTraceLogEntry({
-        phase: input.phase,
+      input.core.createEvoDevExecutionEvent({
+        eventId: input.event?.eventId,
         target: input.target,
-        runtime: {
-          surface: "plugin",
-          argv: input.argv,
-          runtimeFile: import.meta.url,
-        },
-        payload: input.payload,
-        stdinBytes: input.stdinBytes,
-        team: resolveTraceTeamContext({
-          homeDir: input.homeDir,
-          environment: input.environment,
-          payload: input.payload,
-        }),
-        event:
-          input.event === undefined
-            ? null
-            : {
-                eventId: input.event.eventId,
-                type: input.event.type,
-                summary: input.event.payload.summary,
-                metadata: input.event.payload.metadata,
-                decision: input.event.decision,
-              },
-        result:
-          input.result === undefined
-            ? null
-            : {
-                enabled: input.result.enabled,
-                summary: input.result.summary,
-                stateWrites: input.result.stateWrites,
-                warnings: input.result.warnings,
-                formattedResponse: input.formatted?.trim() || null,
-                durationMs: input.durationMs ?? null,
-              },
-        error: input.error,
+        eventType: input.event?.type ?? runtimePhaseEventType(input.phase),
+        sessionKey,
+        projectKey: team?.projectKey ?? null,
+        runId: team?.runId ?? null,
+        roleId: team?.roleId ?? null,
+        taskId: input.event?.scope.taskId ?? null,
+        summary: summarizeExecutionEvent(input),
+        metadata: createExecutionEventMetadata(input),
+        decision: input.event?.decision ?? null,
+        codeAgentTraceRefId: traceRefId,
       }),
     );
   } catch {
-    // Trace logging must never change hook runtime behavior.
+    // Execution event logging must never change hook runtime behavior.
+  }
+}
+
+async function recordTraceRefSafely(input: {
+  core?: HookRuntimeCoreApi;
+  homeDir: string;
+  target: string;
+  payload: Record<string, unknown> | null;
+  event?: HookEventV1;
+  environment?: Record<string, string | undefined>;
+}): Promise<string | null> {
+  if (
+    input.core === undefined ||
+    input.payload === null ||
+    (input.target !== "claude" && input.target !== "codex")
+  ) {
+    return null;
   }
+  try {
+    const record = await input.core.recordCodeAgentTraceRefFromHook({
+      homeDir: input.homeDir,
+      target: input.target,
+      payload: input.payload,
+      environment: input.environment,
+      now:
+        input.event?.time.receivedAt === undefined || input.event.time.receivedAt === "dry-run"
+          ? undefined
+          : input.event.time.receivedAt,
+    });
+    return record?.ref.id ?? null;
+  } catch {
+    return null;
+  }
+}
+
+function runtimePhaseEventType(phase: "started" | "completed" | "failed"): string {
+  if (phase === "started") return "HookRuntimeStarted";
+  if (phase === "completed") return "HookRuntimeCompleted";
+  return "HookRuntimeFailed";
+}
+
+function summarizeExecutionEvent(input: {
+  phase: "started" | "completed" | "failed";
+  event?: HookEventV1;
+  result?: HookRuntimeResult;
+  error?: unknown;
+}): string {
+  if (input.phase === "failed") return "Hook runtime failed before completion.";
+  if (input.result !== undefined) return input.result.summary;
+  if (input.event !== undefined) return input.event.payload.summary;
+  return "Hook runtime started.";
+}
+
+function createExecutionEventMetadata(input: {
+  phase: "started" | "completed" | "failed";
+  stdinBytes: number | null;
+  event?: HookEventV1;
+  result?: HookRuntimeResult;
+  durationMs?: number | null;
+}): Record<string, unknown> {
+  return {
+    phase: input.phase,
+    runtimeSurface: "plugin",
+    stdinBytes: input.stdinBytes,
+    durationMs: input.durationMs ?? null,
+    enabled: input.result?.enabled,
+    stateWriteCount: input.result?.stateWrites.length,
+    warningCount: input.result?.warnings.length,
+    commandClass: input.event?.payload.metadata.commandClass,
+    exitCode: input.event?.payload.metadata.exitCode,
+    status: input.event?.payload.metadata.status ?? input.phase,
+    redactionCount: input.event?.payload.redactionCount,
+    redactionLabels: input.event?.payload.redactions,
+    normalizedEventType: input.event?.type,
+  };
 }
 
 function isNotFoundError(error: unknown): boolean {
@@ -222,7 +292,6 @@ if (import.meta.main) {
   try {
     process.exitCode = await runHookRuntimeCli();
   } catch (error) {
-    console.error(error instanceof Error ? error.message : String(error));
-    process.exitCode = 1;
+    process.exitCode = 0;
   }
 }

package/dist/plugins/evodev/hooks/workspace-core.ts

@@ -108,7 +108,6 @@ async function writeRuntimeCorePackage(input: {
   >;
   const runtimePackageJson = {
     ...sourcePackageJson,
-    exports: rewritePackageExportsToSource(sourcePackageJson.exports),
     files: ["src", "assets", "package.json"],
   };
   await writeFile(
@@ -118,32 +117,6 @@ async function writeRuntimeCorePackage(input: {
   );
 }
 
-function rewritePackageExportsToSource(exportsValue: unknown): unknown {
-  if (typeof exportsValue === "string") {
-    return rewriteDistPathToSource(exportsValue);
-  }
-  if (Array.isArray(exportsValue)) {
-    return exportsValue.map((value) => rewritePackageExportsToSource(value));
-  }
-  if (exportsValue !== null && typeof exportsValue === "object") {
-    return Object.fromEntries(
-      Object.entries(exportsValue).map(([key, value]) => [
-        key,
-        rewritePackageExportsToSource(value),
-      ]),
-    );
-  }
-  return exportsValue;
-}
-
-function rewriteDistPathToSource(path: string): string {
-  if (!path.startsWith("./dist/") || !path.endsWith(".js")) {
-    return path;
-  }
-
-  return `./src/${path.slice("./dist/".length, -".js".length)}.ts`;
-}
-
 async function isDirectory(path: string): Promise<boolean> {
   try {
     return (await stat(path)).isDirectory();

package/dist/plugins/evodev/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evo-dev/plugin",
-  "version": "0.0.1-alpha.1",
+  "version": "0.0.1-alpha.2",
   "type": "module",
   "exports": {
     ".": "./hooks/index.ts"