@cursor/july 0.1.108 → 0.1.111

package/src/channels/slack/tool-cards.ts

@@ -181,7 +181,7 @@ export function createToolCards(
         const details = appendLines(
           tally,
           "details",
-          group.map((call) => cards.details?.(call)).filter(present)
+          group.map(call => cards.details?.(call)).filter(present)
         );
         if (details !== undefined) {
           chunk.details = details;

package/src/channels/slack/tool-chip.ts

@@ -0,0 +1,36 @@
+/**
+ * Shared tool-chip pending lifetime for defaults and agentic delivery.
+ * Always consume on `actions.requested`. Skip the paint when tools are
+ * off or the batch is empty.
+ */
+
+import { truncateTypingStatus } from "./api.js";
+import { firstNonEmptyLine } from "./assistant.js";
+import type { SlackChannelState, SlackToolCall } from "./types.js";
+
+export function rememberPendingToolCall(
+  state: SlackChannelState,
+  finishReason: "stop" | "tool_call",
+  text: string
+): void {
+  if (finishReason === "tool_call") {
+    state.pendingToolCallMessage = firstNonEmptyLine(text) ?? null;
+    return;
+  }
+  state.pendingToolCallMessage = null;
+}
+
+export function takeToolChipLine(
+  state: SlackChannelState,
+  tools: false | ((calls: readonly SlackToolCall[]) => string),
+  calls: readonly SlackToolCall[]
+): string | undefined {
+  const pending = state.pendingToolCallMessage;
+  state.pendingToolCallMessage = null;
+  if (tools === false || calls.length === 0) {
+    return undefined;
+  }
+  return pending !== null
+    ? truncateTypingStatus(pending)
+    : truncateTypingStatus(tools(calls));
+}

package/src/channels/slack/types.ts

@@ -10,6 +10,9 @@ import type {
   ChannelEventHandlers,
   HostContext,
 } from "../../types.js";
+import type { SlackReplyFooter } from "./footer.js";
+
+export type { SlackReplyFooter, SlackReplyFooterContext } from "./footer.js";
 
 /**
  * Pluggable Slack Web API caller. Instead of holding a raw `xoxb-…` token,
@@ -74,6 +77,8 @@ export interface SlackChannelState {
    * Warm turns use this as the `<slack_thread_delta>` watermark.
    */
   lastBotMessageTs?: string | null;
+  /** Admission already posted the static placeholder; execution must not post it again. */
+  placeholderPosted?: boolean;
   /**
    * When true, stream APIs failed for this session — use postMessage
    * for the rest of the turn.
@@ -94,6 +99,12 @@ export interface SlackChannelState {
   reasoningCard?: ReasoningCardState;
   /** `reply.toolCards` per-tool tallies for the current turn, keyed by tool name. */
   toolCardCounts?: Record<string, ToolCardCount>;
+  /** Staged `post-file` uploads this turn (`agentic`). */
+  agenticFiles?: Array<{ path: string; name: string; workspace: string }>;
+  /** Inbound already started ack + chip; `turn.started` skips the backstop. */
+  startPainted?: boolean;
+  /** `Date.now()` at `turn.started`. Footer elapsed time is measured from this. */
+  turnStartedAtMs?: number | null;
 }
 
 /**
@@ -212,11 +223,20 @@ export interface SlackReasoningCardOptions {
  * - `"stream"`: the answer text streams into one message as it is written.
  *   Slack replaces the status chip with its generic "is working…" for the
  *   duration, so live feedback inside the message comes from cards.
+ * - `"agentic"`: inbound still starts turns. At turn start the channel
+ *   acks the parent and raises the thinking chip, then paints thinking
+ *   from `reasoning.appended` and tool lines from `actions.requested`
+ *   (last assistant line before a `tool_call` wins when present).
+ *   Model `set-status` does not own the chip. It does not write tool
+ *   cards, reasoning cards, or assistant text. It watches `post-update`,
+ *   `post-file`, `post-card`, `react`, `edit-message`, and
+ *   `delete-message` and renders those.
  */
 export type SlackReplyOptions =
   | {
       mode: "post";
       status?: SlackStatusOptions;
+      footer?: SlackReplyFooter;
     }
   | {
       mode: "stream";
@@ -225,6 +245,24 @@ export type SlackReplyOptions =
       toolCards?: boolean | SlackToolCardOptions;
       /** Defaults to `false`. */
       reasoningCard?: boolean | SlackReasoningCardOptions;
+      footer?: SlackReplyFooter;
+    }
+  | {
+      mode: "agentic";
+      /**
+       * Reaction on the parent at turn start. Slack name, with or without
+       * colons. Default `eyes`.
+       */
+      ack?: string;
+      /**
+       * Post this exact static line as the first message (`chat.startStream`
+       * when Slack allows, then `stopStream` so the chip can paint). The
+       * first `post-update` edits that same ts. Maximum 80 characters.
+       */
+      placeholder?: string;
+      /** Chip while the turn runs. Reasoning and tools default on. Idle is ignored. */
+      status?: Omit<SlackStatusOptions, "idle">;
+      footer?: SlackReplyFooter;
     };
 
 /**
@@ -643,14 +681,15 @@ export interface SlackChannelOptions {
    */
   events?: ChannelEventHandlers<SlackChannelState>;
   /**
-   * When true (default), reply on final `message.completed` and show typing
-   * via `assistant.threads.setStatus` (and streaming when enabled).
+   * When true (default), install the default turn sinks for `post` and
+   * `stream`, or the signal watcher for `agentic`.
    */
   deliverDefaults?: boolean;
   /**
    * How the reply reaches the thread: status chip + one message at the end
-   * (`"post"`, default), or a live-streamed message with optional tool and
-   * reasoning cards (`"stream"`). See {@link SlackReplyOptions}.
+   * (`"post"`, default), a live-streamed message with optional tool and
+   * reasoning cards (`"stream"`), or agent-owned posts (`"agentic"`).
+   * See {@link SlackReplyOptions}.
    */
   reply?: SlackReplyOptions;
   /** Human labels for tool names in the status chip and cards. */
@@ -667,7 +706,8 @@ export interface SlackChannelOptions {
   thinkingSteps?: boolean;
   /**
    * Write Slack's assistant status chip ("Saw your follow-up…") when a
-   * follow-up coalesces into a running turn. Defaults to `true`.
+   * follow-up coalesces into a running turn. Defaults to `true`, except
+   * when `reply.mode` is `"agentic"`.
    *
    * Set to `false` on channels that report progress themselves: the chip is
    * cleared by the default `message.completed` handler, so a channel that
@@ -717,8 +757,8 @@ export interface SlackChannelOptions {
   /**
    * Built-in Slack `eval` / `eval list` / `eval status` directive that runs
    * playground eval batches (`host.evals` / `/v1/dev/evals/runs`) without an
-   * agent turn. Defaults to `true`. Set `false` to leave `eval …` for the
-   * model handler instead.
+   * agent turn, on mentions and DMs only. Defaults to `true`. Set `false` to
+   * leave `eval …` for the model handler instead.
    */
   evalCommands?: boolean;
   /** Optional teardown (e.g. stop example-local debouncers). Runs after Socket Mode stops. */

package/src/channels/slack/upload.ts

@@ -0,0 +1,142 @@
+import { constants } from "node:fs";
+import { lstat, open, realpath } from "node:fs/promises";
+import { extname, sep } from "node:path";
+import { callSlackApiSoft } from "./api.js";
+import type { SlackBotToken } from "./types.js";
+
+const ALLOWED = new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".svg",
+  ".pdf",
+  ".html",
+  ".txt",
+  ".log",
+  ".json",
+  ".csv",
+  ".md",
+  ".mp4",
+  ".mov",
+  ".webm",
+]);
+
+const MAX_BYTES = 50 * 1024 * 1024;
+
+export interface ThreadFile {
+  path: string;
+  name: string;
+  workspace: string;
+}
+
+async function readJailed(file: ThreadFile): Promise<Buffer | string> {
+  if (file.workspace === "") {
+    return `${file.name}: missing workspace`;
+  }
+  const info = await lstat(file.path);
+  if (info.isSymbolicLink() || !info.isFile()) {
+    return `${file.name}: not a regular file`;
+  }
+  const real = await realpath(file.path);
+  const root = await realpath(file.workspace);
+  if (real !== root && !real.startsWith(`${root}${sep}`)) {
+    return `${file.name}: outside workspace`;
+  }
+  const nofollow = constants.O_NOFOLLOW;
+  const flags =
+    nofollow === undefined ? constants.O_RDONLY : constants.O_RDONLY | nofollow;
+  const handle = await open(file.path, flags);
+  try {
+    const bytes = await handle.readFile();
+    if (bytes.byteLength > MAX_BYTES) {
+      return `${file.name}: over the upload cap`;
+    }
+    const extension = extname(file.path).toLowerCase();
+    if (!ALLOWED.has(extension)) {
+      return `${file.name}: type Slack does not render`;
+    }
+    return bytes;
+  } finally {
+    await handle.close();
+  }
+}
+
+export async function uploadThreadFiles(args: {
+  botToken: SlackBotToken | undefined;
+  channelId: string;
+  threadTs?: string;
+  files: readonly ThreadFile[];
+}): Promise<string[]> {
+  if (args.files.length === 0) {
+    return [];
+  }
+
+  const failures: string[] = [];
+  const uploaded: Array<{ id: string; title: string }> = [];
+  for (const file of args.files) {
+    let bytes: Buffer;
+    try {
+      const read = await readJailed(file);
+      if (typeof read === "string") {
+        failures.push(read);
+        continue;
+      }
+      bytes = read;
+    } catch (error) {
+      failures.push(`${file.name}: gone before upload (${String(error)})`);
+      continue;
+    }
+    const reserved = await callSlackApiSoft({
+      botToken: args.botToken,
+      operation: "files.getUploadURLExternal",
+      body: { filename: file.name, length: bytes.byteLength },
+    });
+    if (!reserved.ok) {
+      failures.push(
+        `${file.name}: could not reserve upload (${reserved.error})`
+      );
+      continue;
+    }
+    const uploadUrl = reserved.upload_url;
+    const fileId = reserved.file_id;
+    if (typeof uploadUrl !== "string" || typeof fileId !== "string") {
+      failures.push(
+        `${file.name}: could not reserve upload (malformed reserve response)`
+      );
+      continue;
+    }
+    try {
+      const put = await fetch(uploadUrl, {
+        method: "POST",
+        body: bytes as unknown as BodyInit,
+      });
+      if (!put.ok) {
+        failures.push(`${file.name}: upload returned ${put.status}`);
+        continue;
+      }
+    } catch (error) {
+      failures.push(`${file.name}: upload failed (${String(error)})`);
+      continue;
+    }
+    uploaded.push({ id: fileId, title: file.name });
+  }
+
+  if (uploaded.length === 0) {
+    return failures;
+  }
+  const shared = await callSlackApiSoft({
+    botToken: args.botToken,
+    operation: "files.completeUploadExternal",
+    body: {
+      files: uploaded,
+      channel_id: args.channelId,
+      thread_ts: args.threadTs,
+    },
+  });
+  if (!shared.ok) {
+    failures.push(`${uploaded.length} file(s): ${String(shared.error)}`);
+  }
+  return failures;
+}

package/src/channels.ts

@@ -1,12 +1,10 @@
 /**
- * `defineChannel` and the built-in HTTP channel — authored at
- * `agent/channels/<name>.ts`.
+ * `defineChannel` — authored at `agent/channels/<name>.ts`.
  *
- * A channel is the surface an agent lives on. The built-in HTTP channel
- * (session create / follow-up / NDJSON stream routes under `/v1/session*`)
- * is always mounted; author `agent/channels/http.ts` with `httpChannel()`
- * only to override its defaults. Custom channels declare their own routes
- * and are mounted under `/v1/channels/<name>`:
+ * A channel is the surface an agent lives on. The built-in HTTP session
+ * channel (session create / follow-up / NDJSON stream routes under
+ * `/v1/session*`) is always mounted. Custom channels declare their own
+ * routes and are mounted under `/v1/channels/<name>`:
  *
  * ```ts
  * import { defineChannel, POST } from "@cursor/july/channels";
@@ -66,9 +64,7 @@ export {
 import { Buffer } from "node:buffer";
 import { createHmac, timingSafeEqual } from "node:crypto";
 import { brandDefinition } from "./internal/brand.js";
-import { normalizeIdentity } from "./internal/continuation-identity.js";
 import { attachCatchAdmission } from "./internal/hosted-catch.js";
-import { attachHttpControlPlaneAdmission } from "./internal/http-control-plane-session.js";
 import { isLoopbackAddress, isLoopbackHostname } from "./internal/net.js";
 import type {
   AuthContext,
@@ -87,6 +83,8 @@ import type {
   RouteMethod,
 } from "./types.js";
 
+/** Configure the built-in HTTP session channel at `agent/channels/http.ts`. */
+export { httpChannel } from "./internal/http-channel-define.js";
 export type {
   AuthContext,
   AuthPolicy,
@@ -109,11 +107,13 @@ export type {
   ChannelStartArgs,
   HttpChannelConfig,
   HttpChannelDefinition,
+  HttpSessionAdmitInfo,
   ReceiveInput,
   RouteMethod,
   SendMessageFn,
   SendMessageOptions,
 } from "./types.js";
+export { HttpSessionAdmitError } from "./types.js";
 
 /** Define a custom channel. */
 export function defineChannel<TState = JsonValue>(
@@ -131,24 +131,6 @@ export function defineChannel<TState = JsonValue>(
   return definition;
 }
 
-/**
- * Configure the built-in HTTP session channel. Only meaningful as the
- * default export of `agent/channels/http.ts`.
- */
-export function httpChannel(
-  config: HttpChannelConfig = {}
-): HttpChannelDefinition {
-  const definition =
-    config.continuation !== undefined
-      ? brandDefinition("http-channel", {
-          ...config,
-          continuation: normalizeIdentity(config.continuation, "http"),
-        })
-      : brandDefinition("http-channel", config);
-  attachHttpControlPlaneAdmission(definition);
-  return definition;
-}
-
 // ============================================================================
 // Route verbs
 // ============================================================================
@@ -378,7 +360,7 @@ export function bearerAuth(
     | string
     | ((token: string) => AuthContext | null | Promise<AuthContext | null>)
 ): AuthPolicy {
-  return async (request) => {
+  return async request => {
     const header = request.headers.get("authorization");
     if (header === null || !header.toLowerCase().startsWith("bearer ")) {
       return null;
@@ -519,7 +501,7 @@ export function sharedSecretAuth(options: {
   secret: string;
 }): AuthPolicy {
   const header = options.header.toLowerCase();
-  const policy: AuthPolicy = (request) => {
+  const policy: AuthPolicy = request => {
     const expected = process.env[options.secret];
     const presented = request.headers.get(header);
     if (
@@ -556,7 +538,7 @@ export function hmacSignatureAuth(options: {
 }): AuthPolicy {
   const header = options.header.toLowerCase();
   const prefix = options.prefix ?? "";
-  const policy: AuthPolicy = async (request) => {
+  const policy: AuthPolicy = async request => {
     const secret = process.env[options.secret];
     const presented = request.headers.get(header)?.trim();
     if (

package/src/dashboard-session-url.ts

@@ -0,0 +1,32 @@
+/**
+ * Hosted dashboard deep-link for a serve session.
+ *
+ * Prefers the playground URL operators already use:
+ * `https://cursor.com/dashboard/deployed-agents/<slug>/playground?sessionId=`
+ * Falls back to `https://cursor.com/agents/<publicId>/<sessionId>` when the
+ * slug is unknown. Returns undefined without a hosted public id so local
+ * serve never emits a broken link.
+ */
+
+const PUBLIC_ID = /^asd_[0-9a-f]{32}$/;
+const SLUG = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+
+export const AGENT_SERVE_PUBLIC_ID_ENV = "AGENT_SERVE_PUBLIC_ID";
+
+export function dashboardSessionUrl(
+  sessionId: string,
+  opts?: { slug?: string; publicId?: string }
+): string | undefined {
+  const publicId = opts?.publicId ?? process.env[AGENT_SERVE_PUBLIC_ID_ENV];
+  if (publicId === undefined || !PUBLIC_ID.test(publicId)) {
+    return undefined;
+  }
+  const origin = (
+    process.env.CURSOR_WEBSITE_URL ?? "https://cursor.com"
+  ).replace(/\/$/, "");
+  const slug = opts?.slug;
+  if (slug !== undefined && SLUG.test(slug)) {
+    return `${origin}/dashboard/deployed-agents/${slug}/playground?sessionId=${encodeURIComponent(sessionId)}`;
+  }
+  return `${origin}/agents/${publicId}/${encodeURIComponent(sessionId)}`;
+}

package/src/evals/assertions.ts

@@ -149,7 +149,7 @@ export class EvalAssertionRecorder {
     const slot = this.slots[this.slots.length - 1]!;
     this.pending.push(
       settle.then(
-        (patch) => {
+        patch => {
           Object.assign(slot, patch);
           if (patch.passed !== undefined) {
             slot.rawPassed = patch.passed;
@@ -181,7 +181,7 @@ export class EvalAssertionRecorder {
   }
 
   results(): EvalAssertionResult[] {
-    return this.slots.map((slot) => ({
+    return this.slots.map(slot => ({
       name: slot.name,
       passed: slot.passed,
       detail: slot.detail,
@@ -249,13 +249,13 @@ export function computeVerdict(
   results: readonly EvalAssertionResult[]
 ): Exclude<EvalVerdict, "skipped"> {
   const failedGate = results.some(
-    (r) => (r.severity ?? "gate") === "gate" && !r.passed
+    r => (r.severity ?? "gate") === "gate" && !r.passed
   );
   if (failedGate) {
     return "failed";
   }
   const missedSoftBar = results.some(
-    (r) =>
+    r =>
       (r.severity ?? "gate") === "soft" &&
       r.threshold !== undefined &&
       !r.passed
@@ -392,7 +392,7 @@ export function createAssertions(
     toolName: string,
     matcher: EvalToolCallMatcher | undefined
   ): EvalToolCallFact[] =>
-    facts().toolCalls.filter((call) => {
+    facts().toolCalls.filter(call => {
       if (call.toolName !== toolName) {
         return false;
       }
@@ -416,7 +416,7 @@ export function createAssertions(
     matcher: EvalEventMatcher | undefined
   ): SessionEvent[] =>
     events().filter(
-      (event) => event.type === type && matchValue(event.data, matcher?.data)
+      event => event.type === type && matchValue(event.data, matcher?.data)
     );
 
   return {
@@ -441,7 +441,7 @@ export function createAssertions(
         name: "parked",
         passed: run.parked && run.turnsFailed === 0,
         detail: run.parked
-          ? pending.map((r) => r.toolName).join(", ")
+          ? pending.map(r => r.toolName).join(", ")
           : "no unanswered approval request",
       });
     },
@@ -463,7 +463,7 @@ export function createAssertions(
       const matched = matchingToolCalls(toolName, matcher);
       const passed = matchCount(matched.length, matcher?.count);
       const observed = facts()
-        .toolCalls.map((c) => c.toolName)
+        .toolCalls.map(c => c.toolName)
         .join(", ");
       return record({
         name: `calledTool(${toolName}${describeMatcherObject(
@@ -487,7 +487,7 @@ export function createAssertions(
 
     loadedSkill(skill: string) {
       const needle = `skills/${skill}/SKILL.md`;
-      const matched = facts().toolCalls.filter((call) =>
+      const matched = facts().toolCalls.filter(call =>
         JSON.stringify(call.input ?? "").includes(needle)
       );
       return record({
@@ -499,7 +499,7 @@ export function createAssertions(
     },
 
     toolOrder(names: readonly string[]) {
-      const called = facts().toolCalls.map((c) => c.toolName);
+      const called = facts().toolCalls.map(c => c.toolName);
       let cursor = 0;
       for (const expected of names) {
         const found = called.indexOf(expected, cursor);
@@ -526,7 +526,7 @@ export function createAssertions(
         detail:
           called.length === 0
             ? undefined
-            : `called [${called.map((c) => c.toolName).join(", ")}]`,
+            : `called [${called.map(c => c.toolName).join(", ")}]`,
       });
     },
 
@@ -547,12 +547,12 @@ export function createAssertions(
         detail:
           failed.length === 0
             ? undefined
-            : failed.map((c) => c.toolName).join(", "),
+            : failed.map(c => c.toolName).join(", "),
       });
     },
 
     calledSubagent(subagentName: string, matcher?: EvalSubagentMatcher) {
-      const matched = facts().subagents.filter((sub) => {
+      const matched = facts().subagents.filter(sub => {
         if (sub.name !== subagentName) {
           return false;
         }
@@ -576,7 +576,7 @@ export function createAssertions(
         detail: passed
           ? undefined
           : `matched ${matched.length}; delegated [${facts()
-              .subagents.map((s) => s.name ?? s.callId)
+              .subagents.map(s => s.name ?? s.callId)
               .join(", ")}]`,
       });
     },
@@ -585,11 +585,11 @@ export function createAssertions(
       kind?: string,
       predicate?: (record: EvalTaggedArtifactFact) => boolean
     ) {
-      const tagged = events().flatMap((event) =>
+      const tagged = events().flatMap(event =>
         event.type === "artifact.tagged" ? [event.data] : []
       );
       const matched = tagged.filter(
-        (record) =>
+        record =>
           (kind === undefined || record.kind === kind) &&
           (predicate === undefined || predicate(record) === true)
       );
@@ -599,7 +599,7 @@ export function createAssertions(
         detail:
           matched.length > 0
             ? undefined
-            : `tagged kinds: [${tagged.map((r) => r.kind).join(", ")}]`,
+            : `tagged kinds: [${tagged.map(r => r.kind).join(", ")}]`,
       });
     },
 
@@ -628,7 +628,7 @@ export function createAssertions(
 
     eventOrder(matchers: readonly EvalEventOrderMatcher[]) {
       const stream = events();
-      const label = `eventOrder([${matchers.map((m) => m.type).join(", ")}])`;
+      const label = `eventOrder([${matchers.map(m => m.type).join(", ")}])`;
       let cursor = 0;
       for (const matcher of matchers) {
         const required = typeof matcher.count === "number" ? matcher.count : 1;
@@ -716,7 +716,7 @@ export function createAssertions(
       args?: EvalMatcher;
     }) {
       const pending = facts().pendingInputRequests.filter(
-        (request) =>
+        request =>
           matchValue(request.toolName, filter?.toolName) &&
           matchValue(request.args, filter?.args)
       );

package/src/evals/expect.ts

@@ -137,7 +137,7 @@ function coerceToString(value: unknown): string {
  */
 function formatIssue(issue: StandardSchemaIssue): string {
   const path = (issue.path ?? [])
-    .map((segment) =>
+    .map(segment =>
       typeof segment === "object" && segment !== null && "key" in segment
         ? String(segment.key)
         : String(segment)

package/src/evals/judge.ts

@@ -135,7 +135,7 @@ function normalizeChoice(
   token: string,
   allowed: readonly string[]
 ): string | undefined {
-  return allowed.find((choice) => choice.toLowerCase() === token.toLowerCase());
+  return allowed.find(choice => choice.toLowerCase() === token.toLowerCase());
 }
 
 function graderFromChoices(args: {

package/src/evals/reporters.ts

@@ -98,12 +98,12 @@ export function renderJUnitXml(
       verdict === "failed" ||
       (verdict === "scored" && summary.strict)
     ) {
-      const failures = result.assertions.filter((a) => !a.passed);
+      const failures = result.assertions.filter(a => !a.passed);
       const message =
         result.error ??
         failures
           .map(
-            (a) => `${a.name}${a.detail === undefined ? "" : ` (${a.detail})`}`
+            a => `${a.name}${a.detail === undefined ? "" : ` (${a.detail})`}`
           )
           .join("; ") ??
         verdict;
@@ -222,7 +222,7 @@ export function Artifacts(options: ArtifactsReporterOptions): EvalReporter {
             ...totals,
             caseCount: results.length,
             target,
-            discovered: discovered.map((e) => e.id),
+            discovered: discovered.map(e => e.id),
           },
           null,
           2
@@ -243,8 +243,8 @@ export function Artifacts(options: ArtifactsReporterOptions): EvalReporter {
 export function sanitizeCaseId(id: string): string {
   return id
     .split("/")
-    .map((segment) => segment.replace(/[^A-Za-z0-9._-]/g, "_"))
-    .filter((segment) => segment !== "" && segment !== "." && segment !== "..")
+    .map(segment => segment.replace(/[^A-Za-z0-9._-]/g, "_"))
+    .filter(segment => segment !== "" && segment !== "." && segment !== "..")
     .join("/");
 }
 
@@ -266,9 +266,8 @@ export function combineReporters(
     }
   };
   return {
-    onRunStart: (evals, target) =>
-      forEach((r) => r.onRunStart?.(evals, target)),
-    onEvalComplete: (result) => forEach((r) => r.onEvalComplete?.(result)),
-    onRunComplete: (summary) => forEach((r) => r.onRunComplete?.(summary)),
+    onRunStart: (evals, target) => forEach(r => r.onRunStart?.(evals, target)),
+    onEvalComplete: result => forEach(r => r.onEvalComplete?.(result)),
+    onRunComplete: summary => forEach(r => r.onRunComplete?.(summary)),
   };
 }

package/src/evals/run-facts.ts

@@ -285,7 +285,7 @@ export function deriveRunFacts(events: readonly SessionEvent[]): EvalRunFacts {
     }
   }
 
-  const pendingInputRequests = inputRequests.filter((r) => !r.resolved);
+  const pendingInputRequests = inputRequests.filter(r => !r.resolved);
   // `turn.*` events all carry a turnId; session-scoped events do not, so the
   // turn count is the number of distinct turn ids seen.
   const turns = turnIds.size;
@@ -301,6 +301,6 @@ export function deriveRunFacts(events: readonly SessionEvent[]): EvalRunFacts {
     ok: failedTurnIds.size === 0 && !sessionFailed && turns > 0,
     assistantMessages,
     assistantText: assistantMessages.join("\n"),
-    failedToolCalls: toolCalls.filter((c) => c.status === "failed"),
+    failedToolCalls: toolCalls.filter(c => c.status === "failed"),
   };
 }