@bjoernrochel/sevro 0.1.0-rc.7 → 1.0.0

package/src/hosts/claude-tool-calls.ts

@@ -1,6 +1,11 @@
 import { sha256 } from "../identity";
 import { isRecord } from "../value-guards";
-import { summarizeClaudeEvents } from "./claude-events";
+import {
+  summarizeClaudeEvents,
+  parseClaudeEvents,
+  type ClaudeEvents,
+  type ClaudeEventLine,
+} from "./claude-events";
 
 const MAX_RETAINED_CALLS = 128;
 type Entry = Record<string, unknown>;
@@ -51,18 +56,18 @@ type Actor = { actor: "parent" | "nested"; parentToolUseId: string | null };
 
 /** Retain ordered host call metadata, never tool prompts or results. */
 export function claudeToolCallsObservation(
-  stream: string,
+  stream: string | ClaudeEvents,
   exitCode: number,
 ): ClaudeToolCallsObservation {
-  const summary = summarizeClaudeEvents(stream, exitCode);
+  const events = parseClaudeEvents(stream);
+  const summary = summarizeClaudeEvents(events, exitCode);
   const state: CallState = {
     calls: [],
     malformed: false,
     truncated: false,
     ordinal: 0,
   };
-  for (const line of stream.split("\n")) {
-    if (!line.trim()) continue;
+  for (const line of events.lines) {
     collectEvent(line, state);
     if (state.truncated) break;
   }
@@ -86,14 +91,12 @@ function callCompleteness(
     : "partial";
 }
 
-function collectEvent(line: string, state: CallState): void {
-  let event: unknown;
-  try {
-    event = JSON.parse(line);
-  } catch {
+function collectEvent(line: ClaudeEventLine, state: CallState): void {
+  if (!line.parsed) {
     state.malformed = true;
     return;
   }
+  const event = line.value;
   if (!isRecord(event) || event.type !== "assistant") return;
   collectAssistant(event, state);
 }

package/src/hosts/claude.ts

@@ -2,36 +2,45 @@ import { existsSync } from "node:fs";
 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 { allocateNativeState } from "../native-transcript-state";
 import {
   failedNativeTranscripts,
   retainEnabledNativeTranscripts,
 } from "../native-transcripts";
-import { fixtureParts } from "../preparation";
+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";
+} from "../runtime/hooks";
+import { insideRuntimeRoot as inside } from "../runtime/paths";
+import { runtimeObservations } from "../runtime/state";
+import { isRecord } from "../value-guards";
 import { runClaudeTurns, type ClaudeSession } from "./claude-continuation";
+import { validateNativeHostRequest, validHostTimeout } from "./native-request";
 import { summarizeClaudeEvents } from "./claude-events";
 import { observeClaudeNativeGoal } from "./claude-native-goal";
-import { claudeNestedSkillsObservation } from "./claude-nested-skills";
 import { runClaudeProcess } from "./claude-process";
 import {
   claudeRepositoryInvocationObservation,
   verifyClaudeRepositoryInvocation,
 } from "./claude-repository-invocation";
 import { prepareClaudeState, type ClaudeHostOptions } from "./claude-state";
+import {
+  cleanupNativeState,
+  createHostDiagnostics,
+  diagnoseHostRequest,
+  diagnosticConfiguration,
+  type HostDiagnostics,
+} from "../host-diagnostics";
+import {
+  CLAUDE_AUTH_VARIABLES,
+  CLAUDE_LOGIN_MARGIN_MS,
+} from "./claude-credential";
 import { claudeToolCallsObservation } from "./claude-tool-calls";
+import { claudeSkillActivationsObservation } from "./claude-skill-activations";
 import { claudeNativeControls } from "./native-controls";
 export type { ClaudeHostOptions } from "./claude-state";
 
@@ -217,12 +226,7 @@ function optionalClaudePaths(options: ClaudeHostOptions): boolean {
   ].every((path) => path === undefined || isAbsolute(path));
 }
 function validClaudeEffortTimeout(effort: string, timeoutMs: number): boolean {
-  return (
-    !!effort &&
-    Number.isSafeInteger(timeoutMs) &&
-    timeoutMs >= 1 &&
-    timeoutMs <= 30 * 60_000
-  );
+  return !!effort && validHostTimeout(timeoutMs);
 }
 
 /** Run Claude with explicit plugins and its native tool sandbox. */
@@ -234,11 +238,17 @@ export function createClaudeHost(options: ClaudeHostOptions): HostAdapter {
     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
@@ -246,7 +256,6 @@ export function createClaudeHost(options: ClaudeHostOptions): HostAdapter {
         : []),
       "sevro.claude.tool-calls",
       "sevro.host.native-controls",
-      "sevro.claude.nested-skills",
       "sevro.host.continuation",
       "sevro.claude.continuation",
     ],
@@ -256,24 +265,6 @@ export function createClaudeHost(options: ClaudeHostOptions): HostAdapter {
   };
 }
 
-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,
@@ -291,42 +282,58 @@ async function runClaudeRequest(
   timeoutMs: number,
   request: Request,
 ): Promise<HostResult> {
-  requireClaudeFollowUp(request);
-  await requireNativeTranscriptView(request.candidateTranscriptRoot);
-  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);
+  const diagnostics = createHostDiagnostics(
+    "claude",
+    options.retainHostDiagnostics,
+    request,
+  );
+  return diagnoseHostRequest(diagnostics, async () => {
+    diagnostics.stage = "request-validation";
+    await diagnostics.readCredentials(options.credentialFile);
+    return executeClaudeRequest(options, timeoutMs, request, diagnostics);
+  });
+}
+
+/** Every turn shares one access token, so it must outlive all of them. */
+function claudeLoginLifetime(timeoutMs: number, request: Request): number {
+  const turns = request.followUpPrompt === undefined ? 1 : 2;
+  return timeoutMs * turns + CLAUDE_LOGIN_MARGIN_MS;
+}
+
+async function executeClaudeRequest(
+  options: ClaudeHostOptions,
+  timeoutMs: number,
+  request: Request,
+  diagnostics: HostDiagnostics,
+): Promise<HostResult> {
+  const { pluginDirs, repositoryInvocation } = await validateClaudeRequest(
+    options,
+    request,
+  );
+  diagnostics.stage = "state-allocation";
   const stateRoot = await allocateNativeState(
     "claude-",
     request.runtimePolicy ? request.workspace : undefined,
   );
   let hooks: HookMounts | undefined;
   try {
+    diagnostics.stage = "state-preparation";
     const state = await prepareClaudeState(
       stateRoot,
       options,
       request,
       pluginDirs,
+      claudeLoginLifetime(timeoutMs, request),
     );
+    diagnostics.registerCredentials(state.env, CLAUDE_AUTH_VARIABLES);
     hooks = state.hooks;
-    const run = (prompt: string, session?: ClaudeSession) =>
-      runClaudeProcess({
-        argv: claudeTurnArgs(
-          options,
-          prompt,
-          session,
-          state.settingsPath,
-          state.pluginDirs,
-        ),
-        cwd: request.workspace,
-        env: state.env,
-        timeoutMs,
-        signal: request.signal,
-      });
+    const run = claudeProcessRunner(
+      options,
+      timeoutMs,
+      request,
+      state,
+      diagnostics,
+    );
     const execution = await runClaudeTurns({
       prompt: request.prompt,
       followUpPrompt: request.followUpPrompt,
@@ -339,6 +346,10 @@ async function runClaudeRequest(
       request,
       repositoryInvocation,
     );
+    await diagnostics.retainFailure(
+      result,
+      "Claude host execution did not complete",
+    );
     await addHookObservation(result, state.hooks);
     await retainEnabledNativeTranscripts(
       result,
@@ -355,13 +366,56 @@ async function runClaudeRequest(
       join(stateRoot, "native-home", "projects"),
       "claude",
       request.runtimeRole,
+      diagnostics,
     );
   } finally {
-    await releaseRuntimeHooks(hooks);
-    await rm(stateRoot, { recursive: true, force: true });
+    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,
+) {
+  return (prompt: string, session?: ClaudeSession) => {
+    diagnostics.stage = "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,
+) {
+  await validateNativeHostRequest(request, "Claude");
+  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,
@@ -433,11 +487,11 @@ async function repositoryObservation(
   if (!invocation) return null;
   return claudeRepositoryInvocationObservation({
     invocation,
-    stream: execution.initialOut ?? execution.out,
+    stream: execution.initialEvents ?? execution.events,
     configRoot: configRoot,
     workspace: request.workspace,
-    tools: execution.initialOut
-      ? claudeToolCallsObservation(execution.initialOut, 0)
+    tools: execution.initialEvents
+      ? claudeToolCallsObservation(execution.initialEvents, 0)
       : tools,
   });
 }
@@ -448,12 +502,7 @@ async function claudeObservations(
   request: Request,
   invocation: RepositoryInvocation | null,
 ) {
-  const nested = await claudeNestedSkillsObservation(
-    execution.out,
-    configRoot,
-    request.workspace,
-  );
-  const tools = claudeToolCallsObservation(execution.out, execution.code);
+  const tools = claudeToolCallsObservation(execution.events, execution.code);
   const repository = await repositoryObservation(
     execution,
     configRoot,
@@ -466,12 +515,12 @@ async function claudeObservations(
     ...runtimeObservations(request.runtimePolicy, request.runtimeRole),
     await observeClaudeNativeGoal(
       configRoot,
-      execution.followUpOut ?? execution.out,
+      execution.followUpEvents ?? execution.events,
     ),
-    nested,
-    claudeNativeControls(execution.out, execution.code),
+    claudeNativeControls(execution.events, execution.code),
     ...(repository ? [repository] : []),
     ...(execution.continuation ? [execution.continuation] : []),
+    claudeSkillActivationsObservation(execution.events, execution.code),
   ];
 }
 
@@ -526,7 +575,7 @@ async function claudeResult(
   request: Request,
   invocation: RepositoryInvocation | null,
 ): Promise<HostResult> {
-  const summary = summarizeClaudeEvents(execution.out, execution.code);
+  const summary = summarizeClaudeEvents(execution.events, execution.code);
   const observations = await claudeObservations(
     execution,
     configRoot,