@cursor/july 0.1.111 → 0.1.112

package/src/internal/filesystem/walk.ts

@@ -7,8 +7,14 @@
 
 import { posix } from "node:path";
 import { minimatch } from "minimatch";
-import type { DirEntry, FileInfo, FileSystem } from "../../filesystem.js";
-import { normalizeFsPath } from "../../filesystem.js";
+import type {
+  DirEntry,
+  FileInfo,
+  FileSystem,
+  GlobOptions,
+  ListOptions,
+} from "../../filesystem.js";
+import { FILE_SYSTEM_SCAN_LIMIT, normalizeFsPath } from "../../filesystem.js";
 import { mergeSorted } from "./merge.js";
 
 /**
@@ -29,13 +35,22 @@ export interface LsDirectoryTreeNode {
 /** Filename-character ingest budget; matches LocalLsExecutor. */
 export const LS_INGEST_CHARACTER_BUDGET = 2_500;
 
+function takeLimit(entries: readonly DirEntry[], limit?: number): DirEntry[] {
+  if (limit === undefined || !Number.isFinite(limit)) {
+    return [...entries];
+  }
+  const cap = Math.max(0, Math.floor(limit));
+  return entries.slice(0, cap);
+}
+
 /**
  * Yield the files under `prefix`, sorted. A file whose path equals
  * `prefix` is not under itself.
  */
 export async function* listFilesFromPaths(
   files: Iterable<DirEntry>,
-  prefix?: string
+  prefix?: string,
+  options?: ListOptions
 ): AsyncGenerator<DirEntry> {
   const scope = normalizeListPrefix(prefix);
   const withSlash = scope === "/" ? "/" : `${scope}/`;
@@ -60,7 +75,7 @@ export async function* listFilesFromPaths(
     );
   }
   matches.sort((left, right) => left.path.localeCompare(right.path));
-  yield* matches;
+  yield* takeLimit(applyIgnores(matches, options?.excludes), options?.limit);
 }
 
 export function normalizeListPrefix(prefix?: string): string {
@@ -97,13 +112,14 @@ export function statFromFilePaths(
 
 export async function collectList(
   root: Pick<FileSystem, "list">,
-  prefix?: string
+  prefix?: string,
+  options?: ListOptions
 ): Promise<DirEntry[]> {
   const entries: DirEntry[] = [];
   if (root.list === undefined) {
     return entries;
   }
-  for await (const entry of root.list(prefix)) {
+  for await (const entry of root.list(prefix, options)) {
     entries.push(entry);
   }
   return entries;
@@ -111,13 +127,19 @@ export async function collectList(
 
 export async function collectGlob(
   root: Pick<FileSystem, "glob">,
-  options: { pattern: string; dir?: string }
+  options: { pattern: string; dir?: string; limit?: number }
 ): Promise<DirEntry[]> {
   const entries: DirEntry[] = [];
   if (root.glob === undefined) {
     return entries;
   }
-  for await (const entry of root.glob(options.pattern, options.dir)) {
+  const globOptions: GlobOptions | undefined =
+    options.limit === undefined ? undefined : { limit: options.limit };
+  for await (const entry of root.glob(
+    options.pattern,
+    options.dir,
+    globOptions
+  )) {
     entries.push(entry);
   }
   return entries;
@@ -129,9 +151,10 @@ export async function collectGlob(
  */
 export async function collectListOrStat(
   root: Pick<FileSystem, "list" | "stat">,
-  path?: string
+  path?: string,
+  options?: ListOptions
 ): Promise<{ kind: FileInfo["kind"]; files: DirEntry[] }> {
-  const files = await collectList(root, path);
+  const files = await collectList(root, path, options);
   if (files.length > 0) {
     return { kind: "directory", files };
   }
@@ -298,10 +321,27 @@ function matchesIgnoreGlob(filePath: string, glob: string): boolean {
     ? glob
     : recursivePrefix + glob;
   const relative = filePath.replace(/^\//, "");
-  return (
-    minimatch(relative, pattern, { dot: true }) ||
-    minimatch(filePath, pattern, { dot: true })
-  );
+  const candidates = [relative, filePath];
+  for (const candidate of candidates) {
+    if (
+      minimatch(candidate, pattern, { dot: true }) ||
+      minimatch(candidate, `${pattern}/**`, { dot: true })
+    ) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/** True when `path` matches any {@link ListOptions.excludes} glob. */
+export function isExcludedPath(
+  path: string,
+  excludes?: readonly string[]
+): boolean {
+  if (excludes === undefined || excludes.length === 0) {
+    return false;
+  }
+  return excludes.some(glob => matchesIgnoreGlob(path, glob));
 }
 
 export async function lsFromList(
@@ -312,7 +352,12 @@ export async function lsFromList(
   | { status: "success"; value: { directoryTreeRoot: LsDirectoryTreeNode } }
   | { status: "error"; error: { message: string } }
 > {
-  const listed = await collectListOrStat(root, path);
+  const listed = await collectListOrStat(root, path, {
+    limit: FILE_SYSTEM_SCAN_LIMIT,
+    ...(ignoreGlobs === undefined || ignoreGlobs.length === 0
+      ? {}
+      : { excludes: ignoreGlobs }),
+  });
   const treePath = path ?? inferListedRoot(listed.files);
   switch (listed.kind) {
     case "missing":

package/src/internal/hosted-admission-adapter.ts

@@ -1,4 +1,5 @@
 import type { ChannelHandlerArgs } from "../types.js";
+import type { HostedAdmissionPlatformHandoff } from "./hosted-delivery-protocol.js";
 
 /**
  * Hosted-admission hook a channel pack attaches to its definition.
@@ -27,6 +28,8 @@ export type HostedAdmissionAdapter = {
     args: ChannelHandlerArgs;
     /** Mailbox key the control plane already allocated for this admission. */
     mailboxContinuationKey?: string;
+    /** Trusted control-plane handoff (Slack placeholder ts, …). */
+    platformHandoff?: HostedAdmissionPlatformHandoff;
   }): Promise<Response>;
 };
 

package/src/internal/hosted-delivery-protocol.ts

@@ -236,6 +236,20 @@ export type HostedAdmissionManagedAutomation = {
   slackChannels?: string[];
 };
 
+/**
+ * Trusted control-plane handoff for a Slack placeholder posted at ingress
+ * before the Temporal signal. Omitted when no placeholder was posted.
+ */
+export type HostedAdmissionPlatformHandoff = {
+  v: 1;
+  slackPlaceholder: {
+    messageTs: string;
+    channelId: string;
+    threadTs: string;
+    streamed: false;
+  };
+};
+
 export type HostedAdmission = {
   v: 2;
   channelId: string;
@@ -251,6 +265,8 @@ export type HostedAdmission = {
   mailboxContinuationKey: string;
   payload: unknown;
   managedAutomation?: HostedAdmissionManagedAutomation;
+  /** Present only when control-plane Slack fast-act posted a placeholder. */
+  platformHandoff?: HostedAdmissionPlatformHandoff;
 };
 
 export type HostedAdmissionOutcome =
@@ -304,12 +320,19 @@ const DELIVERY_KEYS = new Set([
   "mailboxContinuationKey",
   "payload",
   "managedAutomation",
+  "platformHandoff",
 ]);
 const MANAGED_AUTOMATION_KEYS = new Set([
   "automationUuid",
   "mcpServerNames",
   "slackChannels",
 ]);
+export const HOSTED_PLATFORM_HANDOFF_KEYS: ReadonlySet<string> = new Set([
+  "v",
+  "slackPlaceholder",
+]);
+export const HOSTED_SLACK_PLACEHOLDER_HANDOFF_KEYS: ReadonlySet<string> =
+  new Set(["messageTs", "channelId", "threadTs", "streamed"]);
 /** More names than any real automation configures is a malformed envelope. */
 const MANAGED_AUTOMATION_MAX_SERVERS = 64;
 /** More channels than the dashboard picker allows is a malformed envelope. */
@@ -370,6 +393,59 @@ function parseManagedAutomation(
   };
 }
 
+/**
+ * Parse optional control-plane Slack placeholder handoff. Absent → valid;
+ * present-but-malformed → invalid (fail closed like managedAutomation).
+ */
+function parsePlatformHandoff(
+  value: unknown
+): { platformHandoff?: HostedAdmissionPlatformHandoff } | undefined {
+  if (value === undefined) {
+    return {};
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return undefined;
+  }
+  const body = value as Record<string, unknown>;
+  if (
+    Object.keys(body).some(key => !HOSTED_PLATFORM_HANDOFF_KEYS.has(key)) ||
+    body.v !== 1
+  ) {
+    return undefined;
+  }
+  const placeholder = body.slackPlaceholder;
+  if (
+    typeof placeholder !== "object" ||
+    placeholder === null ||
+    Array.isArray(placeholder)
+  ) {
+    return undefined;
+  }
+  const slot = placeholder as Record<string, unknown>;
+  if (
+    Object.keys(slot).some(
+      key => !HOSTED_SLACK_PLACEHOLDER_HANDOFF_KEYS.has(key)
+    ) ||
+    !boundedString(slot.messageTs, 64) ||
+    !boundedString(slot.channelId, 64) ||
+    !boundedString(slot.threadTs, 64) ||
+    slot.streamed !== false
+  ) {
+    return undefined;
+  }
+  return {
+    platformHandoff: {
+      v: 1,
+      slackPlaceholder: {
+        messageTs: slot.messageTs,
+        channelId: slot.channelId,
+        threadTs: slot.threadTs,
+        streamed: slot.streamed,
+      },
+    },
+  };
+}
+
 export function parseHostedAdmission(
   value: unknown
 ): HostedAdmission | undefined {
@@ -387,7 +463,8 @@ export function parseHostedAdmission(
     !boundedString(body.deliveryId, 256) ||
     (body.sessionMode !== "event" && body.sessionMode !== "continuation") ||
     !boundedString(body.mailboxContinuationKey, 512) ||
-    parseManagedAutomation(body.managedAutomation) === undefined
+    parseManagedAutomation(body.managedAutomation) === undefined ||
+    parsePlatformHandoff(body.platformHandoff) === undefined
   ) {
     return undefined;
   }

package/src/internal/hosted-delivery.ts

@@ -391,6 +391,7 @@ async function runAdmission(
       deliveryId: input.delivery.deliveryId,
       args,
       mailboxContinuationKey: input.delivery.mailboxContinuationKey,
+      platformHandoff: input.delivery.platformHandoff,
     });
   } catch (error) {
     const mapped = mappedAdmissionFailure(error);
@@ -948,6 +949,13 @@ export function registerHostedDeliveryRoute(input: {
                   },
                 });
                 sessionId = session.id;
+                // The pre-turn claim used an empty sessionId. Stamp the
+                // engine id now so a dashboard / session-view poll that
+                // only has the factory `ses_…` can follow `session-events/`.
+                await writeDiag({
+                  sessionId,
+                  turnStatus: HOSTED_EXECUTION_DIAG_RUNNING_STATUS,
+                });
                 const outcome = await session.waitForCompletion();
                 completionAt = hostedExecutionNow();
                 // Status is the owner turn. waitForCompletion still waited

package/src/internal/init-project.ts

@@ -81,6 +81,8 @@ const TEMPLATES: Readonly<Record<TemplateName, TemplateEntry>> = {
   "pr-autofixer": { dir: "pr-autofixer" },
   "security-help": { dir: "security-help" },
   "security-reviewer": { dir: "security-reviewer" },
+  "thermo-quality-review": { dir: "thermo-quality-review" },
+  "thermo-review": { dir: "thermo-review" },
   "triage-linear": { dir: "triage", overlay: "linear" },
   "triage-jira": { dir: "triage", overlay: "jira" },
 };
@@ -714,6 +716,8 @@ Scaffold a project, then open the playground:
   npx ${PACKAGE_NAME} init ./code-wiki --template code-wiki       # keep wiki pages current after merge
   npx ${PACKAGE_NAME} init ./agents-md --template agents-md       # keep AGENTS.md current from last week's PRs and Slack
   npx ${PACKAGE_NAME} init ./my-reviewer --template security-reviewer   # review PRs for security bugs
+  npx ${PACKAGE_NAME} init ./thermo-review --template thermo-review       # review PRs for bugs and breakage
+  npx ${PACKAGE_NAME} init ./thermo-quality --template thermo-quality-review # review PRs for code quality
   npx ${PACKAGE_NAME} init ./security-help --template security-help   # answer security questions in Slack
   npx ${PACKAGE_NAME} init ./my-triage --template triage-linear   # comment on Linear issues
   npx ${PACKAGE_NAME} init ./my-triage --template triage-jira     # comment on Jira issues

package/src/internal/server.ts

@@ -238,6 +238,11 @@ import {
   unregisterSessionRunFatalFlush,
 } from "./session-run-log.js";
 import { sessionUrlsForRequest } from "./session-urls.js";
+import {
+  readSkillDetail,
+  skillListEntry,
+  UnknownSkillError,
+} from "./skill-catalog.js";
 import { flushLocalStartLog, selectStartLogStore } from "./start-log-store.js";
 import { catalogDetailEntry, catalogListEntry } from "./tool-catalog.js";
 
@@ -1568,7 +1573,15 @@ function mountAgentRoutes(
     }
     return null;
   };
-  if (noControlPlane === true && isV2Project(project)) {
+  // A v2 mount served under `--no-control-plane` is a hosted v2 guest: the
+  // hosted control plane drives it through the hosted delivery route below.
+  // Session HTTP is a control-plane surface, so such a guest mounts no
+  // `/v1/session*` or `/v1/sessions` routes — session starts arrive as hosted
+  // admissions (`agentsdk.session` on the built-in http channel) and session
+  // reads come from the control plane's runs surface and durable storage.
+  // Local dev, self-hosted serve, and hosted v1 keep the engine mounts.
+  const hostedV2Guest = noControlPlane === true && isV2Project(project);
+  if (hostedV2Guest) {
     registerHostedDeliveryRoute({
       router,
       base,
@@ -1747,34 +1760,38 @@ function mountAgentRoutes(
     },
   });
 
-  router.add({
-    method: "GET",
-    pattern: `${base}/v1/sessions`,
-    auth: httpAuth,
-    handler: async (request, ctx) => {
-      // Same gate as requireSessionOwner / relaxSessionReadAuth: never with
-      // bearer or custom channel auth (strict per-principal isolation).
-      // `--allow-anonymous` alone is a shared-principal trust boundary (corp
-      // Okta ALB); `--dev` alone stays loopback-only.
-      const includeAll =
-        relaxSessionReadAuth &&
-        (relaxSessionReadAuthBeyondLoopback ||
-          (typeof ctx.requestIp === "string" &&
-            isLoopbackAddress(ctx.requestIp)));
-      // `?latest=1` — only the newest visible session. Clients binding a
-      // default session (agsh) do not need the whole list, and on hosted
-      // storage the whole list is a database scan.
-      const latest = new URL(request.url).searchParams.get("latest");
-      const listed =
-        latest === "1" || latest === "true"
-          ? await engine.latestSessionWithSource(ctx.auth, { includeAll })
-          : await engine.listSessionsWithSource(ctx.auth, { includeAll });
-      return jsonResponse({
-        sessions: listed.sessions,
-        source: listed.source,
-      });
-    },
-  });
+  // Session list is session surface: not mounted on a hosted v2 guest (the
+  // control plane owns session reads there; see hostedV2Guest above).
+  if (!hostedV2Guest) {
+    router.add({
+      method: "GET",
+      pattern: `${base}/v1/sessions`,
+      auth: httpAuth,
+      handler: async (request, ctx) => {
+        // Same gate as requireSessionOwner / relaxSessionReadAuth: never with
+        // bearer or custom channel auth (strict per-principal isolation).
+        // `--allow-anonymous` alone is a shared-principal trust boundary (corp
+        // Okta ALB); `--dev` alone stays loopback-only.
+        const includeAll =
+          relaxSessionReadAuth &&
+          (relaxSessionReadAuthBeyondLoopback ||
+            (typeof ctx.requestIp === "string" &&
+              isLoopbackAddress(ctx.requestIp)));
+        // `?latest=1` — only the newest visible session. Clients binding a
+        // default session (agsh) do not need the whole list, and on hosted
+        // storage the whole list is a database scan.
+        const latest = new URL(request.url).searchParams.get("latest");
+        const listed =
+          latest === "1" || latest === "true"
+            ? await engine.latestSessionWithSource(ctx.auth, { includeAll })
+            : await engine.listSessionsWithSource(ctx.auth, { includeAll });
+        return jsonResponse({
+          sessions: listed.sessions,
+          source: listed.source,
+        });
+      },
+    });
+  }
 
   // Durable artifacts (ctx.artifacts / tag_artifact), newest-updated first.
   router.add({
@@ -2084,6 +2101,45 @@ function mountAgentRoutes(
     },
   });
 
+  // Deterministic skill reads: the body the harness would receive, plus
+  // resolved sibling files. Read-only, so plain GETs with no session binding.
+  router.add({
+    method: "GET",
+    pattern: `${base}/v1/skills`,
+    auth: httpAuth,
+    handler: async () =>
+      jsonResponse({
+        skills: project.agent.skills.map(skillListEntry),
+      }),
+  });
+
+  router.add({
+    method: "GET",
+    pattern: `${base}/v1/skills/:skillName`,
+    auth: httpAuth,
+    handler: async (_request, ctx) => {
+      const skillName = ctx.params.skillName ?? "";
+      try {
+        return jsonResponse(
+          await readSkillDetail(project.agent.skills, skillName)
+        );
+      } catch (error) {
+        if (error instanceof UnknownSkillError) {
+          return jsonResponse(
+            {
+              ok: false,
+              error: "unknown_skill",
+              message: error.message,
+              availableSkills: error.availableSkillNames,
+            },
+            { status: 404 }
+          );
+        }
+        throw error;
+      }
+    },
+  });
+
   if (playground) {
     // Serve the built Vite SPA. `<base href>` is injected so the SPA's relative
     // asset URLs resolve under this mount regardless of the trailing slash the
@@ -2107,18 +2163,25 @@ function mountAgentRoutes(
     });
   }
 
-  for (const route of buildHttpChannelRoutes({
-    engine,
-    config: project.httpChannel,
-    auth: httpAuth,
-    basePath: base,
-    // Dev playground lists every session (`includeAll`); allow opening them
-    // (see relaxSessionReadAuth above).
-    relaxSessionReadAuth,
-    relaxSessionReadAuthBeyondLoopback,
-    relaxSessionApprovalAuth,
-  })) {
-    router.add(route);
+  // The built-in HTTP session channel (`/v1/session*`, including the
+  // session-scoped approvals/auths routes) is session surface: not mounted on
+  // a hosted v2 guest (see hostedV2Guest above). The `http` channel itself
+  // stays registered with the hosted delivery route, which is how the control
+  // plane's session starts reach it.
+  if (!hostedV2Guest) {
+    for (const route of buildHttpChannelRoutes({
+      engine,
+      config: project.httpChannel,
+      auth: httpAuth,
+      basePath: base,
+      // Dev playground lists every session (`includeAll`); allow opening them
+      // (see relaxSessionReadAuth above).
+      relaxSessionReadAuth,
+      relaxSessionReadAuthBeyondLoopback,
+      relaxSessionApprovalAuth,
+    })) {
+      router.add(route);
+    }
   }
 
   // Playground eval list/run — available without `--dev` (corp / allow-anonymous).

package/src/internal/session-engine.ts

@@ -1037,6 +1037,11 @@ export class SessionEngine {
       // on a sessionless pod.
       throw new HostedAdmissionLocalSendError();
     }
+    if (options.clearCloudOverride === true && options.cloud !== undefined) {
+      throw new Error(
+        "send options cloud and clearCloudOverride cannot be combined"
+      );
+    }
     const identity =
       channelId === HTTP_CHANNEL_ID
         ? httpContinuationIdentity(this.project.httpChannel)
@@ -1127,11 +1132,18 @@ export class SessionEngine {
             ),
           }));
         }
-        // Refresh the cloud attach the same way: a follow-up send carries the
-        // caller's CURRENT cloud options (e.g. a PR attach re-derived per wake),
-        // and the first send's snapshot must not pin this session's turns to a
-        // stale repo/prUrl for the session's lifetime.
+        // A caller can explicitly return a continuation to the agent's
+        // configured runtime. Omission remains sticky for compatibility:
+        // follow-ups that do not know the original attach keep it.
         if (
+          sendOptions.clearCloudOverride === true &&
+          record.cloudOverride !== undefined
+        ) {
+          record = await this.updateRecord(record.sessionId, current => ({
+            ...current,
+            cloudOverride: undefined,
+          }));
+        } else if (
           sendOptions.cloud !== undefined &&
           JSON.stringify(sendOptions.cloud) !==
             JSON.stringify(record.cloudOverride)

package/src/internal/skill-catalog.ts

@@ -0,0 +1,69 @@
+/**
+ * Deterministic skill reads (`GET /v1/skills`, `GET /v1/skills/:name`,
+ * `agent-sdk skill <name>`): the skill body exactly as the harness would
+ * receive it, plus resolved sibling files. No model turn, no session.
+ */
+
+import { readFile } from "node:fs/promises";
+import type { DiscoveredSkill } from "../types.js";
+import { buildSkillMd } from "./workspace.js";
+
+export class UnknownSkillError extends Error {
+  constructor(
+    skillName: string,
+    readonly availableSkillNames: string[]
+  ) {
+    super(`Unknown skill "${skillName}"`);
+    this.name = "UnknownSkillError";
+  }
+}
+
+/** Light listing entry: routing hint only, like `info` shows. */
+export interface SkillListEntry {
+  name: string;
+  description: string;
+}
+
+/** Full read behind `GET /v1/skills/:name`. */
+export interface SkillDetailEntry extends SkillListEntry {
+  /** SKILL.md body without generated frontmatter. */
+  markdown: string;
+  /** Rendered SKILL.md the harness reads (frontmatter + body). */
+  skillMd: string;
+  /** Sibling files by package-relative path, with contents resolved. */
+  files: Record<string, string>;
+  extension?: string;
+}
+
+export function skillListEntry(skill: DiscoveredSkill): SkillListEntry {
+  return { name: skill.name, description: skill.description };
+}
+
+export async function readSkillDetail(
+  skills: readonly DiscoveredSkill[],
+  skillName: string
+): Promise<SkillDetailEntry> {
+  const skill = skills.find(s => s.name === skillName);
+  if (skill === undefined) {
+    throw new UnknownSkillError(
+      skillName,
+      skills.map(s => s.name)
+    );
+  }
+  // Null-prototype: authored keys (`defineSkill`) pass through
+  // unvalidated, and `__proto__` would silently vanish on a plain object.
+  const files: Record<string, string> = Object.create(null);
+  for (const [rel, source] of Object.entries(skill.files)) {
+    files[rel] =
+      "contents" in source
+        ? source.contents
+        : await readFile(source.sourcePath, "utf8");
+  }
+  return {
+    ...skillListEntry(skill),
+    markdown: skill.markdown,
+    skillMd: buildSkillMd(skill),
+    files,
+    extension: skill.extension,
+  };
+}

package/src/types.ts

@@ -2130,6 +2130,15 @@ export interface SendMessageOptions {
    * runtime is forced local with no override path.
    */
   cloud?: AgentCloudOptions;
+  /**
+   * Clear cloud options retained by an existing continuation session before
+   * starting this turn. Use when a caller intentionally moves a previously
+   * cloud-attached session back to the agent's configured runtime. Cannot be
+   * combined with {@link cloud}.
+   *
+   * On a new session this is a no-op.
+   */
+  clearCloudOverride?: boolean;
   /**
    * Seed the Cursor SDK agent id for a **new** session (ignored when the
    * continuation token matches an existing session). For cloud agents this

package/templates/thermo-quality-review/README.md

@@ -0,0 +1,35 @@
+# Thermo quality review
+
+Reviews pull requests for structural code quality. Posts one review comment.
+
+```bash
+npx @cursor/july init ./thermo-quality-review --template thermo-quality-review
+```
+
+## Run hosted
+
+```bash
+cd thermo-quality-review
+agent-sdk login
+agent-sdk deploy --cursor-events-repo acme/api
+```
+
+The deployment watches that repo through your team's Cursor GitHub
+connection. Open a PR to get a review.
+
+## Run locally
+
+```bash
+agent-sdk dev --cursor-events --repo acme/api
+```
+
+Or replay a PR without pushing:
+
+```bash
+agent-sdk github replay https://github.com/acme/api/pull/12 --dir .
+```
+
+## Files
+
+- `agent/instructions.md`: what counts as a finding
+- `evals/review.eval.ts`: two smoke cases

package/templates/thermo-quality-review/agent/agent.ts

@@ -0,0 +1,8 @@
+import { defineAgent } from "@cursor/july";
+
+export default defineAgent({
+  tools: ["read"],
+  local: {
+    sandbox: true,
+  },
+});