@bjoernrochel/sevro 0.1.0-rc.7 → 1.0.0

package/src/hosts/codex.ts

@@ -1,24 +1,22 @@
 import { existsSync } from "node:fs";
-import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { candidateCodexStateRetained } from "../candidate-codex-state";
+import { lstat, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { isAbsolute, join } from "node:path";
 import type { HostAdapter, HostResult } from "../engine";
-import {
-  allocateNativeState,
-  requireNativeTranscriptView,
-} from "../native-transcript-state";
+import { allocateNativeState } from "../native-transcript-state";
 import {
   failedNativeTranscripts,
   retainEnabledNativeTranscripts,
 } from "../native-transcripts";
-import { runtimeNativeGoalEnabled } from "../runtime-config";
+import { runtimeNativeGoalEnabled } from "../runtime/config";
 import {
   releaseRuntimeHooks,
   runtimeHookObservation,
   type HookMounts,
-} from "../runtime-hooks";
-import { runtimeObservations } from "../runtime-state";
-import { isOptionalNonblankString } from "../value-guards";
+} from "../runtime/hooks";
+import { runtimeObservations } from "../runtime/state";
+import { validateNativeHostRequest, validHostTimeout } from "./native-request";
 import { runCodexAppServer } from "./codex-app-server";
 import { summarizeCodexEvents, type CodexEventSummary } from "./codex-events";
 import { verifyCodexInvocation } from "./codex-invocation";
@@ -26,10 +24,8 @@ import { installCodexPlugins } from "./codex-marketplace";
 import {
   codexNativeCallObservation,
   codexNativeSessionLastOrdinal,
-  codexNativeSkillReadRecovery,
 } from "./codex-native-calls";
-import { runCodexProcess } from "./codex-process";
-import { codexSkillReadObservation } from "./codex-skill-reads";
+import { runCodexProcess, CodexProcessFailure } from "./codex-process";
 import {
   codexHookMounts,
   prepareCodexState,
@@ -37,13 +33,29 @@ import {
 } from "./codex-state";
 import { codexNativeControls } from "./native-controls";
 import { workspaceFingerprint } from "./workspace-fingerprint";
+import { codexSkillCatalogRoots } from "./skill-hook-catalog";
+import {
+  prepareSkillTracking,
+  skillTrackingObservation,
+  skillActivationClaims,
+  skillExposureClaims,
+  type SkillTracking,
+} from "./skill-hooks";
+import {
+  cleanupNativeState,
+  createHostDiagnostics,
+  diagnoseHostRequest,
+  diagnosticConfiguration,
+  type HostDiagnostics,
+} from "../host-diagnostics";
 export type { CodexHostOptions } from "./codex-state";
-const MAX_EVENT_BYTES = 8 * 1024 * 1024;
 const DEFAULT_TIMEOUT_MS = 10 * 60_000;
-const MAX_TIMEOUT_MS = 30 * 60_000;
 
 type Request = Parameters<HostAdapter["run"]>[0];
-type ProcessResult = Awaited<ReturnType<typeof runCodexProcess>>;
+type ProcessResult = Pick<
+  Awaited<ReturnType<typeof runCodexProcess>>,
+  "code" | "out"
+>;
 type AppServerResult = Awaited<ReturnType<typeof runCodexAppServer>>;
 type Observation = {
   id: string;
@@ -56,8 +68,9 @@ interface ExecutionContext {
   request: Request;
   state: CodexState;
   timeoutMs: number;
-  installedPluginRoots: string[];
-  hooks?: HookMounts;
+  hooks: HookMounts;
+  skillTracking: SkillTracking;
+  diagnostics: HostDiagnostics;
 }
 interface TurnResult {
   execution: ProcessResult;
@@ -66,7 +79,6 @@ interface TurnResult {
   followUpSummary: CodexEventSummary | null;
   appServer: AppServerResult | null;
   continuation: Observation | undefined;
-  observedEvents: string;
 }
 
 function validCodexPaths(options: CodexHostOptions): boolean {
@@ -89,13 +101,7 @@ function validEntrypoint(entrypoint: CodexHostOptions["entrypoint"]): boolean {
     entrypoint === undefined || ["exec", "app-server"].includes(entrypoint)
   );
 }
-function validCodexTimeout(timeoutMs: number): boolean {
-  return (
-    Number.isSafeInteger(timeoutMs) &&
-    timeoutMs >= 1 &&
-    timeoutMs <= MAX_TIMEOUT_MS
-  );
-}
+
 function validCodexIdentity(
   options: CodexHostOptions,
   limit: number | null,
@@ -106,7 +112,7 @@ function validCodexIdentity(
     !!options.effort &&
     validEntrypoint(options.entrypoint) &&
     validConcurrencyLimit(limit) &&
-    validCodexTimeout(timeoutMs)
+    validHostTimeout(timeoutMs)
   );
 }
 function codexCapabilities(
@@ -117,21 +123,24 @@ function codexCapabilities(
     "sevro.host.runtime",
     "sevro.host.native-transcripts",
     "sevro.host.hooks",
+    "sevro.host.skill-activations",
+    "sevro.host.skill-activation-claims",
+    "sevro.host.skill-exposure-claims",
     ...(entrypoint === "app-server" ? ["sevro.host.native-goal"] : []),
     "sevro.codex.plugin-marketplace",
     "sevro.codex.explicit-invocation",
     "sevro.codex.repository-invocation",
     "sevro.codex.native-calls",
     "sevro.host.native-controls",
-    "sevro.codex.initial-skill-reads",
-    "sevro.codex.follow-up-skill-reads",
   ];
 }
 function codexConfiguration(
   limit: number | null,
   entrypoint: CodexHostOptions["entrypoint"],
+  retainDiagnostics?: boolean,
 ) {
   return {
+    ...diagnosticConfiguration(retainDiagnostics),
     "sevro.codex.agent-concurrency-limit": limit,
     ...(entrypoint === "app-server"
       ? { "sevro.codex.entrypoint": "app-server" }
@@ -153,30 +162,17 @@ export function createCodexHost(options: CodexHostOptions): HostAdapter {
     hostCapabilities: codexCapabilities(options.entrypoint),
     model: options.model,
     effort: options.effort,
-    configuration: codexConfiguration(limit, options.entrypoint),
+    configuration: codexConfiguration(
+      limit,
+      options.entrypoint,
+      options.retainHostDiagnostics,
+    ),
     run(request) {
       return runCodexRequest(options, timeoutMs, limit, request);
     },
   };
 }
 
-function requireCodexFollowUp(request: Request): void {
-  if (!isOptionalNonblankString(request.followUpPrompt))
-    throw new Error("Codex follow-up prompt must be nonempty");
-}
-function requireCodexFixtureBin(request: Request): void {
-  if (
-    request.fixtureBinDir !== undefined &&
-    request.fixtureBinDir !== join(request.workspace, ".git", "fixture-bin")
-  )
-    throw new Error("fixture binary path is outside the workspace");
-}
-function requirePassiveCodexRequest(request: Request): void {
-  if (request.instrumentation?.length)
-    throw new Error("Codex instrumentation is unavailable");
-  if (request.condition !== "passive")
-    throw new Error("Codex enforcement instrumentation is unavailable");
-}
 function allocateCodexRequestState(request: Request): Promise<string> {
   return allocateNativeState(
     "codex-",
@@ -190,14 +186,27 @@ async function runCodexRequest(
   limit: number | null,
   request: Request,
 ): Promise<HostResult> {
-  requireCodexFollowUp(request);
-  await requireNativeTranscriptView(request.candidateTranscriptRoot);
-  requireCodexFixtureBin(request);
-  requirePassiveCodexRequest(request);
-  requireCodexGoalRoute(request, options);
-  await verifyCodexInvocation(request);
-  if (existsSync(join(request.workspace, ".codex")))
-    throw new Error("fixture Codex configuration is unsupported");
+  const diagnostics = createHostDiagnostics(
+    "codex",
+    options.retainHostDiagnostics,
+    request,
+  );
+  return diagnoseHostRequest(diagnostics, async () => {
+    diagnostics.stage = "request-validation";
+    await diagnostics.readCredentials(options.authFile);
+    return executeCodexRequest(options, timeoutMs, limit, request, diagnostics);
+  });
+}
+
+async function executeCodexRequest(
+  options: CodexHostOptions,
+  timeoutMs: number,
+  limit: number | null,
+  request: Request,
+  diagnostics: HostDiagnostics,
+): Promise<HostResult> {
+  await validateCodexRequest(options, request);
+  diagnostics.stage = "state-allocation";
   const stateRoot = await allocateCodexRequestState(request);
   const helperRoot =
     process.platform === "linux"
@@ -205,6 +214,7 @@ async function runCodexRequest(
       : undefined;
   let activeHooks: HookMounts | undefined;
   try {
+    diagnostics.stage = "state-preparation";
     const state = await prepareCodexState(
       stateRoot,
       options,
@@ -217,29 +227,29 @@ async function runCodexRequest(
       env: state.env,
       pluginCacheRoot: state.pluginCacheRoot,
       request,
+      diagnostics,
     });
+    diagnostics.stage = "hooks-preparation";
     const hooks = await codexHookMounts(request, state, installedPluginRoots);
     activeHooks = hooks;
-    await codexPreflight(options, request, state);
+    const skillTracking = await prepareCodexSkillTracking(
+      state,
+      request,
+      installedPluginRoots,
+    );
+    await codexPreflight(options, request, state, diagnostics);
     const context: ExecutionContext = {
       options,
       request,
       state,
       timeoutMs,
-      installedPluginRoots,
       hooks,
+      skillTracking,
+      diagnostics,
     };
     const turns = await new CodexTurnExecution(context).run();
-    const result = await codexHostResult(context, turns);
-    await retainEnabledNativeTranscripts(
-      result,
-      request.runtimePolicy,
-      join(state.codexHome, "sessions"),
-      "codex",
-      request.runtimeRole,
-      turns.summary.threadId,
-    );
-    return result;
+    if (turns.summary.complete) diagnostics.stage = "result-processing";
+    return await retainCodexResult(context, turns);
   } catch (cause) {
     return await failedNativeTranscripts(
       cause,
@@ -247,14 +257,92 @@ async function runCodexRequest(
       join(stateRoot, "codex-home", "sessions"),
       "codex",
       request.runtimeRole,
+      diagnostics,
     );
   } finally {
-    await releaseRuntimeHooks(activeHooks);
-    await rm(stateRoot, { recursive: true, force: true });
-    if (helperRoot) await rm(helperRoot, { recursive: true, force: true });
+    await cleanupNativeState(diagnostics, async () => {
+      await releaseRuntimeHooks(activeHooks);
+      if (!candidateCodexStateRetained(request.candidateRuntimeRoot, stateRoot))
+        await rm(stateRoot, { recursive: true, force: true });
+      if (helperRoot) await rm(helperRoot, { recursive: true, force: true });
+    });
   }
 }
 
+async function retainCodexResult(context: ExecutionContext, turns: TurnResult) {
+  const result = await codexHostResult(context, turns);
+  await context.diagnostics.retainFailure(
+    result,
+    "Codex host execution did not complete",
+  );
+  await retainEnabledNativeTranscripts(
+    result,
+    context.request.runtimePolicy,
+    join(context.state.codexHome, "sessions"),
+    "codex",
+    context.request.runtimeRole,
+    turns.summary.threadId,
+  );
+  return result;
+}
+
+async function prepareCodexSkillTracking(
+  state: CodexState,
+  request: Request,
+  pluginRoots: string[],
+): Promise<SkillTracking> {
+  const roots = await codexSkillCatalogRoots(request.workspace, pluginRoots, [
+    { directory: join(state.codexHome, "skills"), boundary: state.codexHome },
+    {
+      directory: join(state.parentHome, ".agents/skills"),
+      boundary: state.parentHome,
+    },
+    {
+      directory: join(state.commandHome, ".agents/skills"),
+      boundary: state.commandHome,
+    },
+    {
+      directory: join(state.commandHome, ".codex/skills"),
+      boundary: state.commandHome,
+    },
+  ]);
+  const tracking = await prepareSkillTracking({
+    privateRoot: state.codexHome,
+    host: "codex",
+    roots,
+  });
+  await writeFile(
+    join(state.codexHome, "hooks.json"),
+    JSON.stringify({ hooks: tracking.hooks }),
+    {
+      flag: "wx",
+      mode: 0o600,
+    },
+  );
+  return tracking;
+}
+
+async function validateCodexRequest(
+  options: CodexHostOptions,
+  request: Request,
+): Promise<void> {
+  await validateNativeHostRequest(request, "Codex");
+  requireCodexGoalRoute(request, options);
+  await verifyCodexInvocation(request);
+  await requireCodexFixtureConfiguration(request);
+}
+
+async function requireCodexFixtureConfiguration(
+  request: Request,
+): Promise<void> {
+  const path = join(request.workspace, ".codex");
+  if (!existsSync(path)) return;
+  if (request.runtimePolicy?.codexState !== true)
+    throw new Error("fixture Codex configuration is unsupported");
+  if (!(await lstat(path)).isDirectory())
+    throw new Error("fixture Codex configuration must be a physical directory");
+}
+
 function requireCodexGoalRoute(
   request: Request,
   options: CodexHostOptions,
@@ -284,12 +372,15 @@ async function sandboxPreflight(
   state: CodexState,
   request: Request,
   command: string[],
+  diagnostics: HostDiagnostics,
 ) {
   return runCodexProcess({
+    diagnostics,
     argv: sandboxArgs(state, request, command),
     cwd: request.workspace,
     env: state.env,
     timeoutMs: 60_000,
+    phase: "isolation-preflight",
     signal: request.signal,
   });
 }
@@ -297,22 +388,37 @@ async function codexPreflight(
   options: CodexHostOptions,
   request: Request,
   state: CodexState,
+  diagnostics: HostDiagnostics,
 ): Promise<void> {
+  diagnostics.stage = "isolation-preflight";
   const probe = join(state.commandTemp, "isolation-probe");
   await writeFile(probe, "probe\n", { flag: "wx", mode: 0o600 });
-  const checked = await sandboxPreflight(state, request, [
-    "/bin/sh",
-    "-c",
-    '/bin/cat "$1" >/dev/null && ! /bin/ls "$2" >/dev/null 2>&1 && ! /bin/cat "$3" >/dev/null 2>&1 && ! /bin/cat "$4" >/dev/null 2>&1 || exit 70; "$5" --version >/dev/null 2>&1 || exit 71',
-    "sevro-probe",
-    probe,
-    options.projectRoot,
-    join(state.codexHome, "auth.json"),
-    join(state.codexHome, "config.toml"),
-    state.sandboxBinary,
-  ]);
-  if (checked.code === 71) throw new Error("Codex executable preflight failed");
-  if (checked.code !== 0) throw new Error("Codex isolation preflight failed");
+  const checked = await sandboxPreflight(
+    state,
+    request,
+    [
+      "/bin/sh",
+      "-c",
+      '/bin/cat "$1" >/dev/null && ! /bin/ls "$2" >/dev/null 2>&1 && ! /bin/cat "$3" >/dev/null 2>&1 && ! /bin/cat "$4" >/dev/null 2>&1 || exit 70; "$5" --version >/dev/null 2>&1 || exit 71',
+      "sevro-probe",
+      probe,
+      options.projectRoot,
+      join(state.codexHome, "auth.json"),
+      // The opt-in config read is tested separately; credentials always stay denied.
+      join(
+        state.codexHome,
+        request.runtimePolicy?.codexState === true
+          ? "auth.json"
+          : "config.toml",
+      ),
+      state.sandboxBinary,
+    ],
+    diagnostics,
+  );
+  if (checked.code === 71)
+    throw new CodexProcessFailure("executable-preflight", checked);
+  if (checked.code !== 0)
+    throw new CodexProcessFailure("isolation-preflight", checked);
   await rm(probe);
 }
 
@@ -327,7 +433,7 @@ function routeArgs(context: ExecutionContext): string[] {
     "-c",
     'approval_policy="never"',
     "-c",
-    `features.hooks=${Boolean(context.hooks)}`,
+    "features.hooks=true",
   ];
 }
 function initialTurnArgs(context: ExecutionContext): string[] {
@@ -342,7 +448,7 @@ function initialTurnArgs(context: ExecutionContext): string[] {
       ? []
       : ["--ephemeral"]),
     "--ignore-rules",
-    ...(context.hooks ? ["--dangerously-bypass-hook-trust"] : []),
+    "--dangerously-bypass-hook-trust",
     "-C",
     context.request.workspace,
     ...routeArgs(context),
@@ -361,7 +467,7 @@ function followUpTurnArgs(
     "--strict-config",
     "--skip-git-repo-check",
     "--ignore-rules",
-    ...(context.hooks ? ["--dangerously-bypass-hook-trust"] : []),
+    "--dangerously-bypass-hook-trust",
     ...routeArgs(context),
     threadId,
     "-",
@@ -372,7 +478,9 @@ async function codexProcessTurn(
   argv: string[],
   input: string,
 ): Promise<ProcessResult> {
-  return runCodexProcess({
+  context.diagnostics.stage = "exec";
+  const result = await runCodexProcess({
+    diagnostics: context.diagnostics,
     argv,
     cwd: context.request.workspace,
     env: context.state.env,
@@ -380,6 +488,7 @@ async function codexProcessTurn(
     timeoutMs: context.timeoutMs,
     signal: context.request.signal,
   });
+  return result;
 }
 async function initialFingerprint(request: Request): Promise<string | null> {
   return request.followUpPrompt
@@ -427,43 +536,26 @@ function requireFollowUpCompletion(
       "Codex follow-up turn did not complete in the original thread",
     );
 }
-async function appServerSummary(
-  result: AppServerResult,
-  workspace: string,
-): Promise<CodexEventSummary> {
+function appServerSummary(result: AppServerResult): CodexEventSummary {
   return {
     threadId: result.evidence.threadId ?? "",
     complete: result.code === 0,
-    finalMessage:
-      result.code === 0
-        ? await readFile(join(workspace, ".git", "last-message.md"), "utf8")
-        : null,
+    finalMessage: result.finalMessage,
+    // App-server reports cumulative thread totals, not per-turn usage. Keep
+    // usage unknown rather than count continuations or feedback more than once.
     inputTokens: null,
     outputTokens: null,
     usageComplete: false,
   };
 }
-async function initialSummary(
+function initialSummary(
   appServer: AppServerResult | null,
   execution: ProcessResult,
-  request: Request,
-): Promise<CodexEventSummary> {
+): CodexEventSummary {
   return appServer
-    ? appServerSummary(appServer, request.workspace)
+    ? appServerSummary(appServer)
     : summarizeCodexEvents(execution.out, execution.code);
 }
-function combinedEvents(
-  execution: ProcessResult,
-  followUp: ProcessResult | null,
-): string {
-  const out = followUp
-    ? `${execution.out.trimEnd()}\n${followUp.out.trimStart()}`
-    : execution.out;
-  if (Buffer.byteLength(out, "utf8") > MAX_EVENT_BYTES)
-    throw new Error("Codex combined event stream exceeds the size limit");
-  return out;
-}
-
 class CodexTurnExecution {
   private appServerContinuation?: Observation;
   constructor(private context: ExecutionContext) {}
@@ -477,11 +569,7 @@ class CodexTurnExecution {
         initialTurnArgs(this.context),
         this.context.request.prompt,
       ));
-    const summary = await initialSummary(
-      appServer,
-      execution,
-      this.context.request,
-    );
+    const summary = initialSummary(appServer, execution);
     requireInitialCompletion(summary, appServer);
     const follow = await this.maybeFollowUp(summary, appServer, fingerprint);
     return {
@@ -489,7 +577,6 @@ class CodexTurnExecution {
       summary,
       appServer,
       ...follow,
-      observedEvents: combinedEvents(execution, follow.followUp),
     };
   }
 
@@ -498,7 +585,9 @@ class CodexTurnExecution {
   ): Promise<AppServerResult | null> {
     const { options, request, state, timeoutMs } = this.context;
     if (options.entrypoint !== "app-server") return null;
+    this.context.diagnostics.stage = "app-server";
     return runCodexAppServer({
+      diagnostics: this.context.diagnostics,
       argv: [
         options.binary,
         "app-server",
@@ -507,11 +596,11 @@ class CodexTurnExecution {
         "-c",
         `default_permissions=${JSON.stringify(state.profileId)}`,
         "-c",
-        `features.hooks=${Boolean(this.context.hooks)}`,
+        "features.hooks=true",
       ],
       env: state.env,
       permissionProfile: state.profileId,
-      vettedHooks: Boolean(this.context.hooks),
+      vettedHooks: true,
       request: {
         repoDir: request.workspace,
         prompt: request.prompt,
@@ -568,62 +657,20 @@ class CodexTurnExecution {
   }
 }
 
-type SkillReads = Awaited<ReturnType<typeof codexSkillReadObservation>>;
-async function phaseSkillReads(
-  context: ExecutionContext,
-  turns: TurnResult,
-  recovered: Awaited<ReturnType<typeof codexNativeSkillReadRecovery>>,
-) {
-  if (!turns.followUp) return { initial: null, followUp: null };
-  const initial = {
-    ...(await codexSkillReadObservation(
-      turns.execution.out,
-      context.request.workspace,
-      context.installedPluginRoots,
-      recovered,
-    )),
-    id: "sevro.codex.initial-skill-reads",
-  };
-  const followUp = {
-    ...(await codexSkillReadObservation(
-      turns.followUp.out,
-      context.request.workspace,
-      context.installedPluginRoots,
-      recovered,
-    )),
-    id: "sevro.codex.follow-up-skill-reads",
-  };
-  return { initial, followUp };
-}
 function explicitInvocationReceipt(
   selected: Request["explicitSkillInvocation"],
-  reads: SkillReads,
+  completed: boolean,
 ) {
   if (!selected) return null;
   return {
     id: "sevro.codex.explicit-invocation",
-    completeness: reads.completeness,
+    completeness: completed ? ("complete" as const) : ("partial" as const),
     data: {
       method: "explicit_invocation",
       primarySkill: selected.skillName,
-      observedSkills: [
-        selected.skillName,
-        ...reads.data.observedSkills.filter(
-          (skill) => skill !== selected.skillName,
-        ),
-      ],
     },
   };
 }
-function nativeSkillContext(context: ExecutionContext) {
-  return {
-    workspace: context.request.workspace,
-    installedPluginRoots: context.installedPluginRoots,
-    ...(context.request.followUpPrompt
-      ? { followUpPrompt: context.request.followUpPrompt }
-      : {}),
-  };
-}
 function appServerObservation(result: AppServerResult | null): Observation[] {
   return result
     ? [
@@ -636,45 +683,40 @@ function appServerObservation(result: AppServerResult | null): Observation[] {
     : [];
 }
 async function codexObservations(context: ExecutionContext, turns: TurnResult) {
-  const recovered = await codexNativeSkillReadRecovery(
-    context.state.codexHome,
+  const tracking = await skillTrackingObservation(
+    context.skillTracking,
     turns.summary.threadId,
+    turns.summary.complete,
   );
-  const reads = await codexSkillReadObservation(
-    turns.observedEvents,
-    context.request.workspace,
-    context.installedPluginRoots,
-    recovered,
-  );
-  const phases = await phaseSkillReads(context, turns, recovered);
   const native = await codexNativeCallObservation(
     context.state.codexHome,
     turns.summary.threadId,
-    nativeSkillContext(context),
+    { followUpPrompt: context.request.followUpPrompt },
   );
   const explicit = explicitInvocationReceipt(
     context.request.explicitSkillInvocation,
-    reads,
+    turns.summary.complete,
   );
   return [
-    ...(await codexHookObservations(context.hooks)),
+    ...(await codexHookObservations(context)),
     ...runtimeObservations(
       context.request.runtimePolicy,
       context.request.runtimeRole,
     ),
     ...appServerObservation(turns.appServer),
-    reads,
-    ...(phases.initial ? [phases.initial] : []),
-    ...(phases.followUp ? [phases.followUp] : []),
     native,
     codexNativeControls(native),
     ...(turns.continuation ? [turns.continuation] : []),
     ...(explicit ? [explicit] : []),
+    tracking,
+    ...skillActivationClaims(tracking),
+    ...skillExposureClaims(tracking),
   ];
 }
 
-async function codexHookObservations(hooks: HookMounts | undefined) {
-  return hooks ? [await runtimeHookObservation(hooks)] : [];
+async function codexHookObservations(context: ExecutionContext) {
+  if (!context.request.runtimePolicy) return [];
+  return [await runtimeHookObservation(context.hooks)];
 }
 function codexArtifacts(turns: TurnResult) {
   return [