@bjoernrochel/sevro 0.1.0-rc.2 → 0.1.0-rc.21

package/src/hosts/claude.ts

@@ -1,167 +1,110 @@
-import { observeClaudeNativeGoal } from "./claude-native-goal";
 import { existsSync } from "node:fs";
 import {
-  cp,
-  mkdir,
-  mkdtemp,
-  readFile,
-  realpath,
-  rm,
-  stat,
-  writeFile,
-} from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { delimiter, dirname, isAbsolute, join, relative, sep } from "node:path";
-import type { HostAdapter } from "../engine";
-import { claudeNativeControls } from "./native-controls";
-import { fixtureParts } from "../preparation";
-import { stageClaudeAuthentication } from "./claude-credential";
+  requireCandidateRuntime,
+  requireCandidateArtifactRoots,
+} from "../candidate-artifacts";
+import { readFile, realpath, rm, stat } from "node:fs/promises";
+import { dirname, isAbsolute, join } from "node:path";
+import type { HostAdapter, HostResult } from "../engine";
+import {
+  allocateNativeState,
+  requireNativeTranscriptView,
+} from "../native-transcript-state";
+import {
+  failedNativeTranscripts,
+  retainEnabledNativeTranscripts,
+} from "../native-transcripts";
+import { fixtureParts } from "../fixtures/preparation";
+import {
+  prepareHookMounts,
+  releaseRuntimeHooks,
+  runtimeHookObservation,
+  runtimeHooksEnabled,
+  type HookMounts,
+} from "../runtime/hooks";
+import { insideRuntimeRoot as inside } from "../runtime/paths";
+import { runtimeObservations } from "../runtime/state";
+import { isOptionalNonblankString, isRecord } from "../value-guards";
+import { runClaudeTurns, type ClaudeSession } from "./claude-continuation";
 import { summarizeClaudeEvents } from "./claude-events";
-import { claudeNestedSkillsObservation } from "./claude-nested-skills";
+import { observeClaudeNativeGoal } from "./claude-native-goal";
+import { runClaudeProcess } from "./claude-process";
 import {
   claudeRepositoryInvocationObservation,
   verifyClaudeRepositoryInvocation,
 } from "./claude-repository-invocation";
-import { claudeHostSettings } from "./claude-settings";
+import { prepareClaudeState, type ClaudeHostOptions } from "./claude-state";
+import {
+  cleanupNativeState,
+  createHostDiagnostics,
+  diagnoseHostRequest,
+  diagnosticConfiguration,
+  diagnosticCredentialEnvironment,
+  diagnosticStage,
+  readDiagnosticCredentials,
+  retainReturnedHostFailure,
+  type HostDiagnostics,
+} from "../host-diagnostics";
+import { CLAUDE_AUTH_VARIABLES } from "./claude-credential";
 import { claudeToolCallsObservation } from "./claude-tool-calls";
-import { evaluationProtectedRoots } from "./isolation-roots";
-import { runClaudeTurns, type ClaudeSession } from "./claude-continuation";
+import { claudeSkillActivationsObservation } from "./claude-skill-activations";
+import { claudeNativeControls } from "./native-controls";
+export type { ClaudeHostOptions } from "./claude-state";
 
-const MAX_EVENT_BYTES = 8 * 1024 * 1024;
-const MAX_STDERR_BYTES = 64 * 1024;
 const DEFAULT_TIMEOUT_MS = 10 * 60_000;
 
-export interface ClaudeHostOptions {
-  binary: string;
-  model: string;
-  effort: string;
-  projectRoot: string;
-  resultsRoot: string;
-  additionalProtectedRoots: string[];
-  credentialFile?: string;
-  uvCacheDir?: string;
-  toolchainBinDir?: string;
-  projectSettings?: boolean;
-  timeoutMs?: number;
-}
-
-function inside(root: string, path: string): boolean {
-  const child = relative(root, path);
-  return (
-    child === "" ||
-    (child !== ".." && !child.startsWith(`..${sep}`) && !isAbsolute(child))
-  );
-}
-
-function minimalRoots(roots: string[]): string[] {
-  return roots.filter(
-    (root) => !roots.some((other) => other !== root && inside(other, root)),
-  );
-}
-
-function stop(proc: Bun.Subprocess): void {
-  try {
-    if (process.platform !== "win32") process.kill(-proc.pid, "SIGKILL");
-    else proc.kill("SIGKILL");
-  } catch {
-    proc.kill("SIGKILL");
-  }
-}
-
-async function boundedStream(
-  stream: ReadableStream<Uint8Array>,
-  limit = MAX_EVENT_BYTES,
-): Promise<string> {
-  const reader = stream.getReader();
-  const chunks: Uint8Array[] = [];
-  let size = 0;
-  while (true) {
-    const { value, done } = await reader.read();
-    if (done) break;
-    size += value.byteLength;
-    if (size > limit)
-      throw new Error("Claude process output exceeds its limit");
-    chunks.push(value);
-  }
-  return new TextDecoder("utf-8", { fatal: true }).decode(
-    Buffer.concat(chunks),
-  );
-}
-
-async function runProcess(options: {
-  argv: string[];
-  cwd: string;
-  env: Record<string, string>;
-  timeoutMs: number;
-  signal?: AbortSignal;
-}): Promise<{ code: number; out: string; err: string }> {
-  if (options.signal?.aborted) throw new Error("Claude run cancelled");
-  const proc = Bun.spawn(options.argv, {
-    cwd: options.cwd,
-    env: options.env,
-    detached: process.platform !== "win32",
-    stdin: "ignore",
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  let cancel: (() => void) | undefined;
-  try {
-    const completed = Promise.all([
-      boundedStream(proc.stdout),
-      boundedStream(proc.stderr, MAX_STDERR_BYTES),
-      proc.exited,
-    ]).then(([out, err, code]) => ({ out, err, code }));
-    const timeout = new Promise<never>((_resolve, reject) => {
-      timer = setTimeout(
-        () => reject(new Error("Claude run timed out")),
-        options.timeoutMs,
-      );
-    });
-    const aborted = new Promise<never>((_resolve, reject) => {
-      if (!options.signal) return;
-      cancel = () => reject(new Error("Claude run cancelled"));
-      if (options.signal.aborted) cancel();
-      else options.signal.addEventListener("abort", cancel, { once: true });
-    });
-    return await Promise.race([completed, timeout, aborted]);
-  } catch (error) {
-    stop(proc);
-    await proc.exited;
-    throw error;
-  } finally {
-    if (timer) clearTimeout(timer);
-    if (cancel) options.signal?.removeEventListener("abort", cancel);
-  }
-}
+type Request = Parameters<HostAdapter["run"]>[0];
+type PluginDeclaration = NonNullable<Request["claudePluginDirs"]>;
+type PluginInvocation = NonNullable<Request["explicitSkillInvocation"]> & {
+  scope?: "plugin";
+};
+type RepositoryInvocation = Awaited<
+  ReturnType<typeof verifyClaudeRepositoryInvocation>
+>;
+type Execution = Awaited<ReturnType<typeof runClaudeTurns>>;
 
 async function pluginDirectories(
   workspace: string,
-  declaration: NonNullable<
-    Parameters<HostAdapter["run"]>[0]["claudePluginDirs"]
-  >,
+  declaration: PluginDeclaration,
 ): Promise<string[]> {
   const root = await realpath(workspace);
+  requireUniquePluginDeclaration(declaration);
+  const paths = new Set(declaration.artifactPaths);
+  const directories: string[] = [];
+  for (const relativeRoot of declaration.artifactRoots)
+    directories.push(await declaredPluginDirectory(root, relativeRoot, paths));
+  requireDisjointPluginDirectories(directories);
+  for (const artifactPath of paths)
+    await verifyPluginArtifact(root, artifactPath, declaration, directories);
+  return directories;
+}
+
+function requireUniquePluginDeclaration(declaration: PluginDeclaration): void {
   if (
     new Set(declaration.artifactRoots).size !==
       declaration.artifactRoots.length ||
     new Set(declaration.artifactPaths).size !== declaration.artifactPaths.length
   )
     throw new Error("Claude plugin declaration contains duplicates");
-  const paths = new Set(declaration.artifactPaths);
-  const directories: string[] = [];
-  for (const relativeRoot of declaration.artifactRoots) {
-    fixtureParts(relativeRoot);
-    const manifest = `${relativeRoot}/.claude-plugin/plugin.json`;
-    if (!paths.has(manifest))
-      throw new Error("Claude plugin manifest is undeclared");
-    const actual = await realpath(join(root, relativeRoot));
-    if (!inside(root, actual))
-      throw new Error("Claude plugin directory escapes workspace");
-    if (!(await stat(join(actual, ".claude-plugin", "plugin.json"))).isFile())
-      throw new Error("Claude plugin manifest is missing");
-    directories.push(actual);
-  }
+}
+
+async function declaredPluginDirectory(
+  root: string,
+  relativeRoot: string,
+  paths: Set<string>,
+): Promise<string> {
+  fixtureParts(relativeRoot);
+  if (!paths.has(`${relativeRoot}/.claude-plugin/plugin.json`))
+    throw new Error("Claude plugin manifest is undeclared");
+  const actual = await realpath(join(root, relativeRoot));
+  if (!inside(root, actual))
+    throw new Error("Claude plugin directory escapes workspace");
+  if (!(await stat(join(actual, ".claude-plugin", "plugin.json"))).isFile())
+    throw new Error("Claude plugin manifest is missing");
+  return actual;
+}
+
+function requireDisjointPluginDirectories(directories: string[]): void {
   if (new Set(directories).size !== directories.length)
     throw new Error("Claude plugin directories overlap");
   if (
@@ -170,94 +113,154 @@ async function pluginDirectories(
     )
   )
     throw new Error("Claude plugin directories overlap");
-  for (const artifactPath of paths) {
-    fixtureParts(artifactPath);
-    const index = declaration.artifactRoots.findIndex((item) =>
-      artifactPath.startsWith(`${item}/`),
-    );
-    if (index < 0)
-      throw new Error("Claude plugin artifact is outside a declared directory");
-    if (!inside(directories[index]!, await realpath(join(root, artifactPath))))
-      throw new Error("Claude plugin artifact escapes workspace");
-  }
-  return directories;
 }
 
-async function verifyInvocation(
-  request: Parameters<HostAdapter["run"]>[0],
+async function verifyPluginArtifact(
+  root: string,
+  artifactPath: string,
+  declaration: PluginDeclaration,
   directories: string[],
 ): Promise<void> {
+  fixtureParts(artifactPath);
+  const index = declaration.artifactRoots.findIndex((item) =>
+    artifactPath.startsWith(`${item}/`),
+  );
+  const directory = directories.at(index);
+  if (index < 0 || directory === undefined)
+    throw new Error("Claude plugin artifact is outside a declared directory");
+  if (!inside(directory, await realpath(join(root, artifactPath))))
+    throw new Error("Claude plugin artifact escapes workspace");
+}
+
+function pluginSelection(request: Request): PluginInvocation | null {
   const selected = request.explicitSkillInvocation;
-  if (!selected) return;
-  if (selected.scope === "repository") return;
-  const { pluginName, skillName, token } = selected;
+  if (!selected || selected.scope === "repository") return null;
+  return selected;
+}
+
+function requirePluginInvocation(
+  selected: PluginInvocation,
+  prompt: string,
+): void {
+  const { token, pluginName, skillName } = selected;
   if (
     token !== `/${pluginName}:${skillName}` ||
-    request.prompt.split(token).length - 1 !== 1 ||
+    prompt.split(token).length - 1 !== 1 ||
     !/^[a-z][a-z0-9-]*$/.test(pluginName) ||
     !/^[A-Za-z0-9._-]+$/.test(skillName)
   )
     throw new Error("invalid Claude explicit skill invocation");
+}
+
+function skillPathDeclared(
+  request: Request,
+  index: number,
+  skillName: string,
+): boolean {
+  const relativeRoot = request.claudePluginDirs?.artifactRoots[index];
+  return !!request.claudePluginDirs?.artifactPaths.includes(
+    `${relativeRoot}/skills/${skillName}/SKILL.md`,
+  );
+}
+
+async function verifyInvocation(
+  request: Request,
+  directories: string[],
+): Promise<void> {
+  const selected = pluginSelection(request);
+  if (!selected) return;
+  requirePluginInvocation(selected, request.prompt);
   for (const [index, root] of directories.entries()) {
-    const relativeRoot = request.claudePluginDirs?.artifactRoots[index];
-    if (
-      !request.claudePluginDirs?.artifactPaths.includes(
-        `${relativeRoot}/skills/${skillName}/SKILL.md`,
-      )
-    )
-      continue;
-    let manifest: unknown;
-    try {
-      manifest = JSON.parse(
-        await readFile(join(root, ".claude-plugin", "plugin.json"), "utf8"),
-      );
-    } catch {
-      throw new Error("invalid Claude plugin manifest");
-    }
-    if (
-      manifest &&
-      typeof manifest === "object" &&
-      "name" in manifest &&
-      manifest.name === pluginName &&
-      (
-        await stat(join(root, "skills", skillName, "SKILL.md")).catch(
-          () => null,
-        )
-      )?.isFile()
-    )
-      return;
+    if (!skillPathDeclared(request, index, selected.skillName)) continue;
+    if (await mountedPluginSkill(root, selected)) return;
   }
   throw new Error("invoked Claude skill is absent from the package");
 }
 
+async function mountedPluginSkill(
+  root: string,
+  selected: PluginInvocation,
+): Promise<boolean> {
+  let manifest: unknown;
+  try {
+    manifest = JSON.parse(
+      await readFile(join(root, ".claude-plugin", "plugin.json"), "utf8"),
+    );
+  } catch (error) {
+    throw new Error("invalid Claude plugin manifest", { cause: error });
+  }
+  if (!isRecord(manifest) || manifest.name !== selected.pluginName)
+    return false;
+  const skill = await stat(
+    join(root, "skills", selected.skillName, "SKILL.md"),
+  ).catch(() => null);
+  return !!skill?.isFile();
+}
+
+function validClaudeOptions(
+  options: ClaudeHostOptions,
+  timeoutMs: number,
+): boolean {
+  return (
+    availableClaudeSandbox() &&
+    requiredClaudePaths(options) &&
+    optionalClaudePaths(options) &&
+    !!options.model &&
+    validClaudeEffortTimeout(options.effort, timeoutMs)
+  );
+}
+function availableClaudeSandbox(): boolean {
+  if (process.platform === "darwin") return existsSync("/usr/bin/sandbox-exec");
+  return (
+    process.platform === "linux" &&
+    existsSync("/usr/bin/bwrap") &&
+    existsSync("/usr/bin/socat")
+  );
+}
+function requiredClaudePaths(options: ClaudeHostOptions): boolean {
+  return [
+    options.binary,
+    options.projectRoot,
+    options.resultsRoot,
+    ...options.additionalProtectedRoots,
+  ].every(isAbsolute);
+}
+function optionalClaudePaths(options: ClaudeHostOptions): boolean {
+  return [
+    options.credentialFile,
+    options.uvCacheDir,
+    options.toolchainBinDir,
+  ].every((path) => path === undefined || isAbsolute(path));
+}
+function validClaudeEffortTimeout(effort: string, timeoutMs: number): boolean {
+  return (
+    !!effort &&
+    Number.isSafeInteger(timeoutMs) &&
+    timeoutMs >= 1 &&
+    timeoutMs <= 30 * 60_000
+  );
+}
+
 /** Run Claude with explicit plugins and its native tool sandbox. */
 export function createClaudeHost(options: ClaudeHostOptions): HostAdapter {
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  if (
-    process.platform !== "darwin" ||
-    !existsSync("/usr/bin/sandbox-exec") ||
-    !isAbsolute(options.binary) ||
-    !isAbsolute(options.projectRoot) ||
-    !isAbsolute(options.resultsRoot) ||
-    options.additionalProtectedRoots.some((root) => !isAbsolute(root)) ||
-    (options.credentialFile !== undefined &&
-      !isAbsolute(options.credentialFile)) ||
-    (options.uvCacheDir !== undefined && !isAbsolute(options.uvCacheDir)) ||
-    (options.toolchainBinDir !== undefined &&
-      !isAbsolute(options.toolchainBinDir)) ||
-    !options.model ||
-    !options.effort ||
-    !Number.isSafeInteger(timeoutMs) ||
-    timeoutMs < 1 ||
-    timeoutMs > 30 * 60_000
-  )
+  if (!validClaudeOptions(options, timeoutMs))
     throw new Error("invalid Claude host configuration");
   return {
     id: "sevro.host.claude",
     model: options.model,
     effort: options.effort,
+    ...(options.retainHostDiagnostics
+      ? {
+          configuration: diagnosticConfiguration(options.retainHostDiagnostics),
+        }
+      : {}),
     hostCapabilities: [
       "sevro.host.native-goal",
+      "sevro.host.runtime",
+      "sevro.host.native-transcripts",
+      "sevro.host.hooks",
+      "sevro.host.skill-activations",
       "sevro.claude.plugin-dirs",
       "sevro.claude.explicit-invocation",
       ...(options.projectSettings
@@ -265,256 +268,363 @@ export function createClaudeHost(options: ClaudeHostOptions): HostAdapter {
         : []),
       "sevro.claude.tool-calls",
       "sevro.host.native-controls",
-      "sevro.claude.nested-skills",
       "sevro.host.continuation",
       "sevro.claude.continuation",
     ],
-    async run(request) {
-      if (
-        request.followUpPrompt !== undefined &&
-        (typeof request.followUpPrompt !== "string" ||
-          !request.followUpPrompt.trim())
-      )
-        throw new Error("Claude follow-up prompt must be nonempty");
-      if (request.instrumentation?.length || request.condition !== "passive")
-        throw new Error("Claude enforcement instrumentation is unavailable");
-      if (
-        request.fixtureBinDir !== undefined &&
-        request.fixtureBinDir !== join(request.workspace, ".git", "fixture-bin")
-      )
-        throw new Error("fixture binary path is outside the workspace");
-      const pluginDirs = request.claudePluginDirs
-        ? await pluginDirectories(request.workspace, request.claudePluginDirs)
-        : [];
-      await verifyInvocation(request, pluginDirs);
-      if (
-        request.explicitSkillInvocation?.scope === "repository" &&
-        !options.projectSettings
-      )
-        throw new Error(
-          "Claude repository invocation requires project setting sources",
-        );
-      const repositoryInvocation =
-        request.explicitSkillInvocation?.scope === "repository"
-          ? await verifyClaudeRepositoryInvocation(request)
-          : null;
-      const stateRoot = await mkdtemp(join(tmpdir(), "sevro-claude-state-"));
-      try {
-        await mkdir(join(stateRoot, "private"), { mode: 0o700 });
-        const privateRoot = await realpath(join(stateRoot, "private"));
-        const home = join(stateRoot, "home");
-        const temp = join(stateRoot, "tmp");
-        await Promise.all(
-          [home, temp].map((path) => mkdir(path, { mode: 0o700 })),
-        );
-        const authentication = await stageClaudeAuthentication(
-          join(privateRoot, "config"),
-          options.credentialFile,
-        );
-        const credential = authentication.credentialFile;
-        const protectedRoots = minimalRoots(
-          await evaluationProtectedRoots({
-            workspace: request.workspace,
-            projectRoot: options.projectRoot,
-            resultsRoot: options.resultsRoot,
-            additionalRoots: options.additionalProtectedRoots,
-          }),
-        );
-        if (protectedRoots.some((root) => inside(root, credential)))
-          throw new Error("Claude private state overlaps a protected root");
-        const binaryRoot = await realpath(options.binary);
-        if (protectedRoots.some((root) => inside(root, binaryRoot)))
-          throw new Error("Claude executable resides inside a protected root");
-        const toolchainBinDir = options.toolchainBinDir
-          ? await realpath(options.toolchainBinDir)
-          : null;
-        if (
-          toolchainBinDir &&
-          (protectedRoots.some((root) => inside(root, toolchainBinDir)) ||
-            !(await stat(toolchainBinDir)).isDirectory())
-        )
-          throw new Error(
-            "Claude toolchain directory is unavailable or protected",
-          );
-        let runtimeRoot: string | null = null;
-        if (options.uvCacheDir) {
-          const cacheRoot = await realpath(options.uvCacheDir);
-          if (
-            protectedRoots.some((root) => inside(root, cacheRoot)) ||
-            !(await stat(cacheRoot)).isDirectory()
-          )
-            throw new Error("Claude UV cache is unavailable or protected");
-          runtimeRoot = join(request.workspace, ".git", "sevro-runtime");
-          await mkdir(runtimeRoot, { recursive: true, mode: 0o700 });
-          await cp(cacheRoot, join(runtimeRoot, "uv-cache"), {
-            recursive: true,
-            force: false,
-            errorOnExist: true,
-          });
-        }
-        const settingsPath = join(privateRoot, "settings.json");
-        await writeFile(
-          settingsPath,
-          JSON.stringify(
-            claudeHostSettings(
-              privateRoot,
-              credential,
-              pluginDirs,
-              protectedRoots,
-            ),
-          ),
-          { flag: "wx", mode: 0o600 },
-        );
-        const env: Record<string, string> = {
-          ...authentication.environment,
-          CLAUDE_CODE_SUBPROCESS_ENV_SCRUB: "1",
-          PATH: [
-            request.fixtureBinDir,
-            toolchainBinDir,
-            process.env.PATH ?? "/usr/bin:/bin",
-          ]
-            .filter(Boolean)
-            .join(delimiter),
-          LANG: process.env.LANG ?? "C",
-          HOME: runtimeRoot ? join(runtimeRoot, "host-home") : home,
-          TMPDIR: temp,
-          CLAUDE_CONFIG_DIR: dirname(credential),
-          NO_COLOR: "1",
-          ...(runtimeRoot
-            ? {
-                UV_CACHE_DIR: join(runtimeRoot, "uv-cache"),
-                UV_PROJECT_ENVIRONMENT: join(
-                  runtimeRoot,
-                  "project-environment",
-                ),
-                UV_OFFLINE: "1",
-                PYTHONDONTWRITEBYTECODE: "1",
-              }
-            : {}),
-        };
-        if (runtimeRoot) await mkdir(env.HOME!, { mode: 0o700 });
-        const runTurn = (prompt: string, session?: ClaudeSession) =>
-          runProcess({
-            argv: [
-              options.binary,
-              "-p",
-              prompt,
-              "--output-format",
-              "stream-json",
-              "--verbose",
-              "--model",
-              options.model,
-              "--effort",
-              options.effort,
-              "--permission-mode",
-              "dontAsk",
-              "--tools",
-              "Bash,Read,Edit,Skill,Agent",
-              "--setting-sources",
-              options.projectSettings ? "project" : "",
-              "--settings",
-              settingsPath,
-              "--strict-mcp-config",
-              "--mcp-config",
-              '{"mcpServers":{}}',
-              "--no-chrome",
-              ...(session ? [session.option, session.id] : []),
-              ...pluginDirs.flatMap((path) => ["--plugin-dir", path]),
-            ],
-            cwd: request.workspace,
-            env,
-            timeoutMs,
-            signal: request.signal,
-          });
-        const execution = await runClaudeTurns({
-          prompt: request.prompt,
-          followUpPrompt: request.followUpPrompt,
-          workspace: request.workspace,
-          run: runTurn,
-        });
-        const summary = summarizeClaudeEvents(execution.out, execution.code);
-        const nestedSkills = await claudeNestedSkillsObservation(
-          execution.out,
-          dirname(credential),
-          request.workspace,
-        );
-        const toolCalls = claudeToolCallsObservation(
-          execution.out,
-          execution.code,
-        );
-        const repositoryObservation = repositoryInvocation
-          ? await claudeRepositoryInvocationObservation({
-              invocation: repositoryInvocation,
-              stream: execution.initialOut ?? execution.out,
-              configRoot: dirname(credential),
-              workspace: request.workspace,
-              tools: execution.initialOut
-                ? claudeToolCallsObservation(execution.initialOut, 0)
-                : toolCalls,
-            })
-          : null;
-        return {
-          finalMessage: summary.finalMessage,
-          complete: summary.complete,
-          executionFailed: !summary.complete,
-          observations: [
-            toolCalls,
-            await observeClaudeNativeGoal(
-              dirname(credential),
-              execution.followUpOut ?? execution.out,
-            ),
-            nestedSkills,
-            claudeNativeControls(execution.out, execution.code),
-            ...(repositoryObservation ? [repositoryObservation] : []),
-            ...(execution.continuation ? [execution.continuation] : []),
-          ],
-          artifacts: [
-            {
-              id: "sevro.claude.events",
-              bytes: Buffer.from(execution.out, "utf8"),
-            },
-            ...(execution.initialOut !== undefined
-              ? [
-                  {
-                    id: "sevro.claude.initial-events",
-                    bytes: Buffer.from(execution.initialOut, "utf8"),
-                  },
-                ]
-              : []),
-            ...(execution.followUpOut !== undefined
-              ? [
-                  {
-                    id: "sevro.claude.follow-up-events",
-                    bytes: Buffer.from(execution.followUpOut, "utf8"),
-                  },
-                ]
-              : []),
-            ...(execution.err
-              ? [
-                  {
-                    id: "sevro.claude.stderr",
-                    bytes: Buffer.from(execution.err, "utf8"),
-                  },
-                ]
-              : []),
-          ],
-          actualCondition: "passive" as const,
-          inputTokens:
-            execution.sessionResultsBound === false
-              ? null
-              : summary.inputTokens,
-          outputTokens:
-            execution.sessionResultsBound === false
-              ? null
-              : summary.outputTokens,
-          costUsd:
-            execution.sessionResultsBound === false ? null : summary.costUsd,
-          usageComplete:
-            execution.sessionResultsBound !== false && summary.usageComplete,
-        };
-      } finally {
-        await rm(stateRoot, { recursive: true, force: true });
-      }
+    run(request) {
+      return runClaudeRequest(options, timeoutMs, request);
     },
   };
 }
+
+function requireClaudeFollowUp(request: Request): void {
+  if (!isOptionalNonblankString(request.followUpPrompt))
+    throw new Error("Claude follow-up prompt must be nonempty");
+}
+function requirePassiveClaudeRequest(request: Request): void {
+  if (request.instrumentation?.length || request.condition !== "passive")
+    throw new Error("Claude enforcement instrumentation is unavailable");
+  requireClaudeFixtureBin(request);
+}
+
+function requireClaudeFixtureBin(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");
+}
+
+async function repositoryMount(
+  request: Request,
+  options: ClaudeHostOptions,
+): Promise<RepositoryInvocation | null> {
+  if (request.explicitSkillInvocation?.scope !== "repository") return null;
+  if (!options.projectSettings)
+    throw new Error(
+      "Claude repository invocation requires project setting sources",
+    );
+  return verifyClaudeRepositoryInvocation(request);
+}
+
+async function runClaudeRequest(
+  options: ClaudeHostOptions,
+  timeoutMs: number,
+  request: Request,
+): Promise<HostResult> {
+  const diagnostics = createHostDiagnostics(
+    "claude",
+    options.retainHostDiagnostics,
+    request,
+  );
+  return diagnoseHostRequest(diagnostics, async () => {
+    diagnosticStage(diagnostics, "request-validation");
+    await readDiagnosticCredentials(diagnostics, options.credentialFile);
+    return executeClaudeRequest(options, timeoutMs, request, diagnostics);
+  });
+}
+
+async function executeClaudeRequest(
+  options: ClaudeHostOptions,
+  timeoutMs: number,
+  request: Request,
+  diagnostics?: HostDiagnostics,
+): Promise<HostResult> {
+  const { pluginDirs, repositoryInvocation } = await validateClaudeRequest(
+    options,
+    request,
+  );
+  diagnosticStage(diagnostics, "state-allocation");
+  const stateRoot = await allocateNativeState(
+    "claude-",
+    request.runtimePolicy ? request.workspace : undefined,
+  );
+  let hooks: HookMounts | undefined;
+  try {
+    diagnosticStage(diagnostics, "state-preparation");
+    const state = await prepareClaudeState(
+      stateRoot,
+      options,
+      request,
+      pluginDirs,
+    );
+    await readDiagnosticCredentials(diagnostics, state.credential);
+    diagnosticCredentialEnvironment(
+      diagnostics,
+      state.env,
+      CLAUDE_AUTH_VARIABLES,
+    );
+    hooks = state.hooks;
+    const run = claudeProcessRunner(
+      options,
+      timeoutMs,
+      request,
+      state,
+      diagnostics,
+    );
+    const execution = await runClaudeTurns({
+      prompt: request.prompt,
+      followUpPrompt: request.followUpPrompt,
+      workspace: request.workspace,
+      run,
+    });
+    const result = await claudeResult(
+      execution,
+      claudeObservationRoot(stateRoot, state.credential, request),
+      request,
+      repositoryInvocation,
+    );
+    await retainReturnedHostFailure(
+      diagnostics,
+      result,
+      "Claude host execution did not complete",
+    );
+    await addHookObservation(result, state.hooks);
+    await retainEnabledNativeTranscripts(
+      result,
+      request.runtimePolicy,
+      join(stateRoot, "native-home", "projects"),
+      "claude",
+      request.runtimeRole,
+    );
+    return result;
+  } catch (cause) {
+    return await failedNativeTranscripts(
+      cause,
+      request.runtimePolicy,
+      join(stateRoot, "native-home", "projects"),
+      "claude",
+      request.runtimeRole,
+      diagnostics,
+    );
+  } finally {
+    await cleanupNativeState(diagnostics, async () => {
+      await releaseRuntimeHooks(hooks);
+      await rm(stateRoot, { recursive: true, force: true });
+    });
+  }
+}
+
+function claudeProcessRunner(
+  options: ClaudeHostOptions,
+  timeoutMs: number,
+  request: Request,
+  state: Awaited<ReturnType<typeof prepareClaudeState>>,
+  diagnostics: HostDiagnostics | undefined,
+) {
+  return (prompt: string, session?: ClaudeSession) => {
+    diagnosticStage(diagnostics, "claude-execution");
+    return runClaudeProcess({
+      diagnostics,
+      argv: claudeTurnArgs(
+        options,
+        prompt,
+        session,
+        state.settingsPath,
+        state.pluginDirs,
+      ),
+      cwd: request.workspace,
+      env: state.env,
+      timeoutMs,
+      signal: request.signal,
+    });
+  };
+}
+
+async function validateClaudeRequest(
+  options: ClaudeHostOptions,
+  request: Request,
+) {
+  requireClaudeFollowUp(request);
+  await requireNativeTranscriptView(request.candidateTranscriptRoot);
+  await requireCandidateRuntime(
+    request.candidateRuntimeRoot,
+    request.runtimeRole,
+  );
+  await requireCandidateArtifactRoots(request.candidateArtifactRoots);
+  requirePassiveClaudeRequest(request);
+  const pluginDirs = request.claudePluginDirs
+    ? await pluginDirectories(request.workspace, request.claudePluginDirs)
+    : [];
+  await verifyInvocation(request, pluginDirs);
+  requireIsolatedHookSources(request, options);
+  const repositoryInvocation = await repositoryMount(request, options);
+  return { pluginDirs, repositoryInvocation };
+}
+
+function requireIsolatedHookSources(
+  request: Request,
+  options: ClaudeHostOptions,
+): void {
+  if (runtimeHooksEnabled(request.runtimePolicy) && options.projectSettings)
+    throw new Error("native goals require isolated hook sources");
+}
+
+async function addHookObservation(
+  result: HostResult,
+  hooks: Awaited<ReturnType<typeof prepareHookMounts>> | undefined,
+): Promise<void> {
+  if (!hooks) return;
+  result.observations?.push(await runtimeHookObservation(hooks));
+}
+
+function claudeTurnArgs(
+  options: ClaudeHostOptions,
+  prompt: string,
+  session: ClaudeSession | undefined,
+  settingsPath: string,
+  pluginDirs: string[],
+): string[] {
+  return [
+    options.binary,
+    "-p",
+    prompt,
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    "--model",
+    options.model,
+    "--effort",
+    options.effort,
+    "--permission-mode",
+    "dontAsk",
+    "--tools",
+    "Bash,Read,Edit,Skill,Agent",
+    "--setting-sources",
+    options.projectSettings ? "project" : "",
+    "--settings",
+    settingsPath,
+    "--strict-mcp-config",
+    "--mcp-config",
+    '{"mcpServers":{}}',
+    "--no-chrome",
+    ...(session ? [session.option, session.id] : []),
+    ...pluginDirs.flatMap((path) => ["--plugin-dir", path]),
+  ];
+}
+
+function claudeObservationRoot(
+  stateRoot: string,
+  credential: string,
+  request: Request,
+): string {
+  return request.runtimePolicy?.nativeTranscripts === true
+    ? join(stateRoot, "native-home")
+    : dirname(credential);
+}
+
+async function repositoryObservation(
+  execution: Execution,
+  configRoot: string,
+  request: Request,
+  invocation: RepositoryInvocation | null,
+  tools: ReturnType<typeof claudeToolCallsObservation>,
+) {
+  if (!invocation) return null;
+  return claudeRepositoryInvocationObservation({
+    invocation,
+    stream: execution.initialOut ?? execution.out,
+    configRoot: configRoot,
+    workspace: request.workspace,
+    tools: execution.initialOut
+      ? claudeToolCallsObservation(execution.initialOut, 0)
+      : tools,
+  });
+}
+
+async function claudeObservations(
+  execution: Execution,
+  configRoot: string,
+  request: Request,
+  invocation: RepositoryInvocation | null,
+) {
+  const tools = claudeToolCallsObservation(execution.out, execution.code);
+  const repository = await repositoryObservation(
+    execution,
+    configRoot,
+    request,
+    invocation,
+    tools,
+  );
+  return [
+    tools,
+    ...runtimeObservations(request.runtimePolicy, request.runtimeRole),
+    await observeClaudeNativeGoal(
+      configRoot,
+      execution.followUpOut ?? execution.out,
+    ),
+    claudeNativeControls(execution.out, execution.code),
+    ...(repository ? [repository] : []),
+    ...(execution.continuation ? [execution.continuation] : []),
+    claudeSkillActivationsObservation(execution.out, execution.code),
+  ];
+}
+
+function claudeArtifacts(execution: Execution) {
+  return [
+    { id: "sevro.claude.events", bytes: Buffer.from(execution.out, "utf8") },
+    ...(execution.initialOut !== undefined
+      ? [
+          {
+            id: "sevro.claude.initial-events",
+            bytes: Buffer.from(execution.initialOut, "utf8"),
+          },
+        ]
+      : []),
+    ...(execution.followUpOut !== undefined
+      ? [
+          {
+            id: "sevro.claude.follow-up-events",
+            bytes: Buffer.from(execution.followUpOut, "utf8"),
+          },
+        ]
+      : []),
+    ...(execution.err
+      ? [
+          {
+            id: "sevro.claude.stderr",
+            bytes: Buffer.from(execution.err, "utf8"),
+          },
+        ]
+      : []),
+  ];
+}
+
+function measuredClaudeUsage(
+  summary: ReturnType<typeof summarizeClaudeEvents>,
+  execution: Execution,
+) {
+  return {
+    inputTokens:
+      execution.sessionResultsBound === false ? null : summary.inputTokens,
+    outputTokens:
+      execution.sessionResultsBound === false ? null : summary.outputTokens,
+    costUsd: execution.sessionResultsBound === false ? null : summary.costUsd,
+    usageComplete:
+      execution.sessionResultsBound !== false && summary.usageComplete,
+  };
+}
+
+async function claudeResult(
+  execution: Execution,
+  configRoot: string,
+  request: Request,
+  invocation: RepositoryInvocation | null,
+): Promise<HostResult> {
+  const summary = summarizeClaudeEvents(execution.out, execution.code);
+  const observations = await claudeObservations(
+    execution,
+    configRoot,
+    request,
+    invocation,
+  );
+  return {
+    finalMessage: summary.finalMessage,
+    complete: summary.complete,
+    executionFailed: !summary.complete,
+    observations,
+    artifacts: claudeArtifacts(execution),
+    actualCondition: "passive",
+    ...measuredClaudeUsage(summary, execution),
+  };
+}