@cursor/bdk 0.2.1

package/src/internal/discovery/project.ts

@@ -0,0 +1,319 @@
+/**
+ * Project roots and mounts: find agents under a directory and load them into {@link AgentProject} manifests.
+ */
+
+import { basename, join, resolve } from "node:path";
+import type { AgentProject, ArtifactsDefinition, Diagnostic } from "../../types.js";
+import { registerAuthoredModuleLoaders } from "../authored-loaders.js";
+import {
+  applyAgentContinuationDefaults,
+  warnOmittedContinuationDowngrades,
+} from "../continuation-channel.js";
+import { httpChannel } from "../http-channel-define.js";
+import { loadAgent, warnUnknownSlots } from "./agent.js";
+import { loadChannels } from "./channels.js";
+import {
+  type DiscoveryContext,
+  defaultImportModule,
+  displayPath,
+  type LoadAgentProjectOptions,
+} from "./context.js";
+import { hasFlatLayoutMarkers, isDirectory, readPackageName, sortedEntries } from "./fs.js";
+import { loadHooks } from "./hooks.js";
+import { NAME_PATTERN } from "./names.js";
+import { loadReminders } from "./reminders.js";
+import { loadSchedules } from "./schedules.js";
+import {
+  appendArtifactTool,
+  loadArtifacts,
+  loadOtel,
+  loadStorage,
+  mergeArtifacts,
+  rejectLegacyResult,
+} from "./services.js";
+
+/**
+ * True when `dir` looks like an agent project root: it has a nested `bot/`
+ * directory, a compatible `agent/` directory, or flat-layout markers
+ * (`agent.ts` / `instructions.md`) directly inside it.
+ */
+export async function isAgentProjectDir(dir: string): Promise<boolean> {
+  const resolved = resolve(dir);
+  if (!(await isDirectory(resolved))) {
+    return false;
+  }
+  if ((await nestedProjectDir(resolved)) !== undefined) {
+    return true;
+  }
+  return hasFlatLayoutMarkers(resolved);
+}
+
+async function nestedProjectDir(rootDir: string): Promise<string | undefined> {
+  for (const name of ["bot", "agent"]) {
+    const candidate = join(rootDir, name);
+    if (await isDirectory(candidate)) {
+      return candidate;
+    }
+  }
+  return undefined;
+}
+
+/** One immediate child agent directory under a multi-agent parent. */
+export interface ChildAgentDir {
+  slug: string;
+  dir: string;
+}
+
+/**
+ * List agent projects directly under `rootDir` (one level deep) without
+ * loading them. Empty when the path is missing or has no child agents.
+ * Slug rules match {@link loadAgentProjects} / multi-agent serve.
+ */
+export async function listChildAgentDirs(rootDir: string): Promise<ChildAgentDir[]> {
+  const resolved = resolve(rootDir);
+  if (!(await isDirectory(resolved))) {
+    return [];
+  }
+
+  const results: ChildAgentDir[] = [];
+  const seenSlugs = new Set<string>();
+  for (const entry of await sortedEntries(resolved)) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) {
+      continue;
+    }
+    if (entry.name === "node_modules") {
+      continue;
+    }
+    const childDir = join(resolved, entry.name);
+    if (!(await isAgentProjectDir(childDir))) {
+      continue;
+    }
+    const slug = assertSlug(entry.name, resolved);
+    if (seenSlugs.has(slug)) {
+      throw new Error(`Duplicate agent slug "${slug}" under ${resolved}.`);
+    }
+    seenSlugs.add(slug);
+    results.push({ slug, dir: childDir });
+  }
+  return results;
+}
+
+/**
+ * Discover the agent projects directly under `rootDir` (one level deep):
+ * each immediate child directory that is itself an agent project becomes a
+ * mounted agent, keyed by a slug derived from its directory name. Used for
+ * multi-agent serving, where one server hosts many agents under
+ * `/<slug>/...`. Throws when no child projects are found.
+ */
+export async function loadAgentProjects(
+  rootDir: string,
+  options: LoadAgentProjectOptions = {},
+): Promise<Array<{ slug: string; project: AgentProject }>> {
+  const resolved = resolve(rootDir);
+  if (!(await isDirectory(resolved))) {
+    throw new Error(`Agent projects directory does not exist: ${resolved}`);
+  }
+
+  const children = await listChildAgentDirs(resolved);
+  if (children.length === 0) {
+    throw new Error(
+      `No agent projects found directly under ${resolved}. Each agent should be a subdirectory with its own bot/ directory (or flat-layout markers).`,
+    );
+  }
+  const results: Array<{ slug: string; project: AgentProject }> = [];
+  // Storage namespaces (session mirror, host kv) key on the project
+  // NAME, not the mount slug — two co-hosted agents sharing a name would
+  // silently share sessions and KV state.
+  const slugByName = new Map<string, string>();
+  for (const child of children) {
+    const project = await loadAgentProject(child.dir, options);
+    const priorSlug = slugByName.get(project.name);
+    if (priorSlug !== undefined) {
+      throw new Error(
+        `Duplicate agent name "${project.name}" under ${resolved}: agents "${priorSlug}" and "${child.slug}" both resolve to it (package.json "name", or the directory name when unset). Co-hosted agents must have distinct names — their storage and session namespaces key on the name.`,
+      );
+    }
+    slugByName.set(project.name, child.slug);
+    results.push({ slug: child.slug, project });
+  }
+  return results;
+}
+
+/**
+ * Resolve mounts for `serve` / CLI. Defaults to multi-agent layout:
+ * - `mode: "single"` — one agent at `/v1/*` (empty slug).
+ * - otherwise, if `rootDir` is itself an agent project — one agent under
+ *   `/<dirname>/...`.
+ * - otherwise, every immediate child agent project under `/<slug>/...`.
+ */
+export async function resolveAgentMounts(
+  rootDir: string,
+  options: LoadAgentProjectOptions & {
+    mode?: "single" | "multi";
+  } = {},
+): Promise<Array<{ slug: string; project: AgentProject }>> {
+  const { mode = "multi", ...discovery } = options;
+  if (mode === "single") {
+    return [{ slug: "", project: await loadAgentProject(rootDir, discovery) }];
+  }
+  if (await isAgentProjectDir(rootDir)) {
+    const resolved = resolve(rootDir);
+    const slug = assertSlug(basename(resolved), resolved);
+    return [
+      {
+        slug,
+        project: await loadAgentProject(rootDir, discovery),
+      },
+    ];
+  }
+  return loadAgentProjects(rootDir, discovery);
+}
+
+function assertSlug(name: string, parentDir: string): string {
+  if (!NAME_PATTERN.test(name) || RESERVED_SLUGS.has(name)) {
+    throw new Error(
+      `Cannot mount agent directory "${name}" under ${parentDir}: its name must match ${NAME_PATTERN} and not be one of ${[...RESERVED_SLUGS].join(", ")}.`,
+    );
+  }
+  return name;
+}
+
+/** URL path segments reserved by the server; agents cannot use them as slugs. */
+const RESERVED_SLUGS: Set<string> = new Set(["v1", "playground", "docs"]);
+
+export async function loadAgentProject(
+  dir: string,
+  options: LoadAgentProjectOptions = {},
+): Promise<AgentProject> {
+  // Public API: embedders can call discovery directly (without `serve()` or
+  // the CLI), and it dynamically imports authored TypeScript.
+  await registerAuthoredModuleLoaders();
+  const rootDir = resolve(dir);
+  if (!(await isDirectory(rootDir))) {
+    throw new Error(`Agent project directory does not exist: ${rootDir}`);
+  }
+
+  const nestedAgentDir = await nestedProjectDir(rootDir);
+  let agentDir: string;
+  if (nestedAgentDir !== undefined) {
+    agentDir = nestedAgentDir;
+  } else if (await hasFlatLayoutMarkers(rootDir)) {
+    agentDir = rootDir;
+  } else {
+    throw new Error(
+      `No agent found under ${rootDir}: expected a bot/ directory (or a flat layout with agent.ts / instructions.md at the root)`,
+    );
+  }
+
+  const diagnostics: Diagnostic[] = [];
+  const ctx: DiscoveryContext = {
+    rootDir,
+    diagnostics,
+    importModule: options.importModule ?? defaultImportModule,
+  };
+
+  const name = (await readPackageName(rootDir)) ?? basename(rootDir);
+  const { agent, projectSlots } = await loadAgent(ctx, agentDir, {
+    name,
+    isRoot: true,
+  });
+
+  const { channels, httpChannelDefinition } = await loadChannels(ctx, join(agentDir, "channels"));
+  for (const channel of projectSlots.channels) {
+    if (channel.id === "http" || channels.some(c => c.id === channel.id)) {
+      ctx.diagnostics.push({
+        severity: "error",
+        path: displayPath(ctx, join(agentDir, "extensions")),
+        message: `Extension channel "${channel.id}" collides with an agent channel.`,
+      });
+      continue;
+    }
+    channels.push(channel);
+  }
+  const schedules = await loadSchedules(ctx, join(agentDir, "schedules"));
+  schedules.push(...projectSlots.schedules);
+  const reminders = await loadReminders(ctx, join(agentDir, "reminders"));
+  const hooks = await loadHooks(ctx, join(agentDir, "hooks"));
+  hooks.push(...projectSlots.hooks);
+  const storage = await loadStorage(ctx, agentDir, agent.architecture);
+  const artifacts = await mergeProjectArtifacts(ctx, agentDir, projectSlots.artifacts);
+  const otel = await loadOtel(ctx, agentDir);
+  await rejectLegacyResult(ctx, agentDir);
+  await appendArtifactTool(ctx, agentDir, agent, artifacts);
+
+  if (agentDir !== rootDir) {
+    await warnUnknownSlots(ctx, agentDir);
+  }
+
+  const resolvedHttpChannel = httpChannelDefinition ?? httpChannel();
+  warnOmittedContinuationDowngrades({
+    architecture: agent.architecture,
+    channels,
+    warn: (id, message) => {
+      ctx.diagnostics.push({
+        severity: "warning",
+        path: displayPath(ctx, join(agentDir, "channels", `${id}.ts`)),
+        message,
+      });
+    },
+  });
+  applyAgentContinuationDefaults({
+    agent,
+    channels,
+    httpChannel: resolvedHttpChannel,
+  });
+
+  return {
+    rootDir,
+    agentDir,
+    name: agent.name,
+    agent,
+    httpChannel: resolvedHttpChannel,
+    channels,
+    schedules,
+    reminders,
+    hooks,
+    storage,
+    artifacts,
+    otel,
+    diagnostics,
+  };
+}
+
+async function mergeProjectArtifacts(
+  ctx: DiscoveryContext,
+  agentDir: string,
+  extra: ArtifactsDefinition | undefined,
+): Promise<ArtifactsDefinition | undefined> {
+  const agent = await loadArtifacts(ctx, agentDir);
+  if (extra === undefined) {
+    return agent;
+  }
+  const kinds = { ...extra.kinds };
+  const agentKinds = agent?.kinds;
+  for (const kind of Object.keys(kinds)) {
+    if (agentKinds !== undefined && kind in agentKinds) {
+      ctx.diagnostics.push({
+        severity: "error",
+        path: displayPath(ctx, join(agentDir, "extensions")),
+        message: `Extension artifact kind "${kind}" collides with an agent kind.`,
+      });
+      delete kinds[kind];
+    }
+  }
+  return mergeArtifacts(agent, { ...extra, kinds });
+}
+
+/** True when the project has diagnostics that must block serving. */
+export function hasErrorDiagnostics(project: AgentProject): boolean {
+  return project.diagnostics.some(d => d.severity === "error");
+}
+
+export function formatDiagnostics(diagnostics: Diagnostic[]): string {
+  return diagnostics
+    .map(d => {
+      const location = d.path === undefined ? "" : ` (${d.path})`;
+      return `${d.severity}: ${d.message}${location}`;
+    })
+    .join("\n");
+}

package/src/internal/discovery/reminders.ts

@@ -0,0 +1,65 @@
+/**
+ * `agent/reminders/*.ts`: named durable reminder fire handlers.
+ */
+
+import { basename, extname, relative } from "node:path";
+import type { DiscoveredReminder, ReminderDefinition } from "../../types.js";
+import { getDefinitionKind } from "../brand.js";
+import { type DiscoveryContext, displayPath } from "./context.js";
+import { isDirectory, isModuleFile, toPosix, walkFiles } from "./fs.js";
+import { importDefault } from "./modules.js";
+import { NAME_PATTERN } from "./names.js";
+
+export async function loadReminders(
+  ctx: DiscoveryContext,
+  remindersDir: string,
+  onDisable?: (name: string, path: string) => void,
+): Promise<DiscoveredReminder[]> {
+  if (!(await isDirectory(remindersDir))) {
+    return [];
+  }
+  const reminders: DiscoveredReminder[] = [];
+  for (const filePath of await walkFiles(remindersDir)) {
+    const rel = toPosix(relative(remindersDir, filePath));
+    if (!isModuleFile(basename(filePath))) {
+      continue;
+    }
+    const name = rel.slice(0, -extname(rel).length);
+    if (!NAME_PATTERN.test(name) || name.includes("__")) {
+      ctx.diagnostics.push({
+        severity: "error",
+        path: displayPath(ctx, filePath),
+        message: name.includes("__")
+          ? `Reminder name "${name}" may not contain "__"; it is reserved for extension contributions (\`<ns>__<name>\`).`
+          : `Reminder name "${name}" must match ${NAME_PATTERN}.`,
+      });
+      continue;
+    }
+    const definition = await importDefault(
+      ctx,
+      filePath,
+      onDisable === undefined ? "reminder" : ["reminder", "disabled"],
+    );
+    if (definition === undefined) {
+      continue;
+    }
+    if (getDefinitionKind(definition) === "disabled") {
+      onDisable?.(name, filePath);
+      continue;
+    }
+    const reminder = definition as ReminderDefinition;
+    if (typeof reminder.run !== "function") {
+      ctx.diagnostics.push({
+        severity: "error",
+        path: displayPath(ctx, filePath),
+        message: "Reminder handlers require a `run` function.",
+      });
+      continue;
+    }
+    reminders.push({
+      name,
+      definition: reminder,
+    });
+  }
+  return reminders;
+}

package/src/internal/discovery/runtime.ts

@@ -0,0 +1,158 @@
+/**
+ * Runtime resolution and the limitations each runtime imposes on the authored surface.
+ */
+
+import { join } from "node:path";
+import type { AgentRuntime } from "../../types.js";
+import { type DiscoveryContext, displayPath } from "./context.js";
+
+/**
+ * Validate the authored runtime. An unrecognized value is an error
+ * diagnostic and falls back to local — a typo must not silently pick a
+ * different harness for every turn.
+ */
+export function resolveRuntime(
+  ctx: DiscoveryContext,
+  agentDir: string,
+  runtime: AgentRuntime | undefined,
+): AgentRuntime {
+  if (
+    runtime === undefined ||
+    runtime === "local" ||
+    runtime === "cloud" ||
+    runtime === "grokbot"
+  ) {
+    return runtime ?? "local";
+  }
+  ctx.diagnostics.push({
+    severity: "error",
+    path: displayPath(ctx, join(agentDir, "agent.ts")),
+    message: `runtime must be "local", "cloud", or "grokbot"; got ${JSON.stringify(runtime)}.`,
+  });
+  return "local";
+}
+
+/**
+ * Grok Bot turns run on the Sand harness with its own toolset: authored
+ * server tools, MCP connections, and subagents have no path onto that
+ * toolset yet, so an agent declaring them must fail at serve start rather
+ * than run with capabilities silently missing.
+ */
+export function checkGrokBotRuntimeLimitations(
+  ctx: DiscoveryContext,
+  agentDir: string,
+  counts: {
+    serverTools: number;
+    agentTools: number;
+    skills: number;
+    seedFiles: number;
+    connections: number;
+    subagents: number;
+    hasCloudOptions: boolean;
+    hasLocalSandbox: boolean;
+  },
+): void {
+  const agentPath = displayPath(ctx, join(agentDir, "agent.ts"));
+  const error = (path: string, message: string): void => {
+    ctx.diagnostics.push({ severity: "error", path, message });
+  };
+  const warn = (path: string, message: string): void => {
+    ctx.diagnostics.push({ severity: "warning", path, message });
+  };
+  if (counts.serverTools > 0) {
+    error(
+      displayPath(ctx, join(agentDir, "tools")),
+      'Server tools (execution: "server", including opted-in builtinTools) are not reachable from grokbot turns yet. Remove them or run the agent on the local runtime.',
+    );
+  }
+  if (counts.connections > 0) {
+    error(
+      displayPath(ctx, agentDir),
+      "MCP connections under mcp-connections/ or host-connections/ are not wired into grokbot turns yet. Remove them or run the agent on the local runtime.",
+    );
+  }
+  if (counts.subagents > 0) {
+    error(
+      displayPath(ctx, join(agentDir, "subagents")),
+      "Authored subagents are not available on grokbot turns (the Grok Bot harness runs its own subagent set). Remove them or run the agent on the local runtime.",
+    );
+  }
+  // The remaining declarations mirror the cloud runtime's warnings: the
+  // turn runs on a hosted machine (the account's box), so local-workspace
+  // materialization never reaches it.
+  if (counts.agentTools > 0) {
+    warn(
+      displayPath(ctx, join(agentDir, "tools")),
+      'Agent tools (execution: "agent") are described in the hosted session\'s instructions (with script bodies); they are not written onto the box filesystem automatically.',
+    );
+  }
+  if (counts.skills > 0) {
+    warn(
+      displayPath(ctx, join(agentDir, "skills")),
+      "Authored skills are materialized into the local session workspace only; the hosted Grok Bot box does not see them.",
+    );
+  }
+  if (counts.seedFiles > 0) {
+    warn(
+      displayPath(ctx, join(agentDir, "sandbox")),
+      "sandbox/workspace seed files apply to the local session workspace only; grokbot turns run on the account's hosted box.",
+    );
+  }
+  if (counts.hasCloudOptions) {
+    warn(
+      agentPath,
+      'The `cloud` block is unused on runtime: "grokbot", and grokbot sessions refuse per-session cloud attach.',
+    );
+  }
+  if (counts.hasLocalSandbox) {
+    warn(
+      agentPath,
+      'local.sandbox does not apply to runtime: "grokbot"; the box is the account\'s Cursor-hosted computer.',
+    );
+  }
+}
+
+export function warnCloudRuntimeLimitations(
+  ctx: DiscoveryContext,
+  agentDir: string,
+  counts: {
+    agentTools: number;
+    skills: number;
+    seedFiles: number;
+    hasCloudOptions: boolean;
+  },
+): void {
+  const agentPath = displayPath(ctx, join(agentDir, "agent.ts"));
+  if (!counts.hasCloudOptions) {
+    ctx.diagnostics.push({
+      severity: "warning",
+      path: agentPath,
+      message:
+        'runtime: "cloud" usually needs a `cloud` block (e.g. repos / env). Without it the Cursor cloud API may reject create.',
+    });
+  }
+  if (counts.agentTools > 0) {
+    ctx.diagnostics.push({
+      severity: "warning",
+      path: displayPath(ctx, join(agentDir, "tools")),
+      message:
+        'Agent tools (execution: "agent") are described on the first cloud prompt (with script bodies); they are not written into the cloud VM filesystem automatically.',
+    });
+  }
+  if (counts.skills > 0) {
+    ctx.diagnostics.push({
+      severity: "warning",
+      path: displayPath(ctx, join(agentDir, "skills")),
+      message:
+        "Authored skills reach cloud agents through native store discovery: hosted deployments write the deployment store's skills/ directory; local serve/run with a personal API key writes agent-serve/<agent>/skills/ on the USER store. Without a reachable store, only skills already in the cloud repo are visible.",
+    });
+  }
+  if (counts.seedFiles > 0) {
+    ctx.diagnostics.push({
+      severity: "warning",
+      path: displayPath(ctx, join(agentDir, "sandbox")),
+      message:
+        "sandbox/workspace seed files reach cloud agents through the Agent Store, not the checkout: hosted deployments write the deployment store's workspace/ directory; local serve/run with a personal API key writes agent-serve/<agent>/workspace/ on the USER store. The first cloud prompt names the mounted directory. Without a reachable store, cloud turns do not see them.",
+    });
+  }
+}

package/src/internal/discovery/schedules.ts

@@ -0,0 +1,120 @@
+/**
+ * `agent/schedules/*.ts`: cron-driven runs.
+ */
+
+import { readFile } from "node:fs/promises";
+import { basename, extname, relative } from "node:path";
+import type { DiscoveredSchedule, ScheduleDefinition } from "../../types.js";
+import { getDefinitionKind } from "../brand.js";
+import { isValidCron } from "../cron.js";
+import { parseFrontmatter } from "../frontmatter.js";
+import { type DiscoveryContext, displayPath } from "./context.js";
+import { isDirectory, isModuleFile, toPosix, walkFiles } from "./fs.js";
+import { importDefault } from "./modules.js";
+
+export async function loadSchedules(
+  ctx: DiscoveryContext,
+  schedulesDir: string,
+  onDisable?: (name: string, path: string) => void,
+): Promise<DiscoveredSchedule[]> {
+  if (!(await isDirectory(schedulesDir))) {
+    return [];
+  }
+  const schedules: DiscoveredSchedule[] = [];
+  for (const filePath of await walkFiles(schedulesDir)) {
+    const rel = toPosix(relative(schedulesDir, filePath));
+    if (rel.endsWith(".md")) {
+      const name = rel.slice(0, -".md".length);
+      if (name.includes("__")) {
+        ctx.diagnostics.push({
+          severity: "error",
+          path: displayPath(ctx, filePath),
+          message: `Schedule name "${name}" may not contain "__"; it is reserved for extension contributions (\`<ns>__<name>\`).`,
+        });
+        continue;
+      }
+      const { data, body } = parseFrontmatter(await readFile(filePath, "utf8"));
+      const cron = data.cron;
+      if (cron === undefined || !isValidCron(cron)) {
+        ctx.diagnostics.push({
+          severity: "error",
+          path: displayPath(ctx, filePath),
+          message:
+            cron === undefined
+              ? "Markdown schedules require `cron` frontmatter."
+              : `Invalid cron expression: "${cron}".`,
+        });
+        continue;
+      }
+      const markdown = body.trim();
+      if (markdown === "") {
+        ctx.diagnostics.push({
+          severity: "error",
+          path: displayPath(ctx, filePath),
+          message: "Markdown schedules require a non-empty prompt body.",
+        });
+        continue;
+      }
+      schedules.push({
+        name,
+        cron,
+        kind: "markdown",
+        definition: {
+          __agentServe: "schedule",
+          cron,
+          markdown,
+        },
+      });
+      continue;
+    }
+
+    if (!isModuleFile(basename(filePath))) {
+      continue;
+    }
+    const name = rel.slice(0, -extname(rel).length);
+    if (name.includes("__")) {
+      ctx.diagnostics.push({
+        severity: "error",
+        path: displayPath(ctx, filePath),
+        message: `Schedule name "${name}" may not contain "__"; it is reserved for extension contributions (\`<ns>__<name>\`).`,
+      });
+      continue;
+    }
+    const definition = await importDefault(
+      ctx,
+      filePath,
+      onDisable === undefined ? "schedule" : ["schedule", "disabled"],
+    );
+    if (definition === undefined) {
+      continue;
+    }
+    if (getDefinitionKind(definition) === "disabled") {
+      onDisable?.(name, filePath);
+      continue;
+    }
+    const schedule = definition as ScheduleDefinition;
+    if ((schedule.markdown === undefined) === (schedule.run === undefined)) {
+      ctx.diagnostics.push({
+        severity: "error",
+        path: displayPath(ctx, filePath),
+        message: "Schedules require exactly one of `markdown` or `run`.",
+      });
+      continue;
+    }
+    if (!isValidCron(schedule.cron)) {
+      ctx.diagnostics.push({
+        severity: "error",
+        path: displayPath(ctx, filePath),
+        message: `Invalid cron expression: "${schedule.cron}".`,
+      });
+      continue;
+    }
+    schedules.push({
+      name,
+      cron: schedule.cron,
+      kind: schedule.run === undefined ? "markdown" : "run",
+      definition: schedule,
+    });
+  }
+  return schedules;
+}

package/src/internal/discovery/seed-files.ts

@@ -0,0 +1,34 @@
+/**
+ * `agent/sandbox/workspace/**`: files seeded into each local session workspace.
+ */
+
+import { join, relative } from "node:path";
+import type { SeedFile } from "../../types.js";
+import { type DiscoveryContext, displayPath } from "./context.js";
+import { isDirectory, isFile, toPosix, walkFiles } from "./fs.js";
+
+export async function loadSeedFiles(ctx: DiscoveryContext, agentDir: string): Promise<SeedFile[]> {
+  const sandboxDir = join(agentDir, "sandbox");
+  for (const candidate of ["sandbox.ts", join("sandbox", "sandbox.ts")]) {
+    if (await isFile(join(agentDir, candidate))) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        path: displayPath(ctx, join(agentDir, candidate)),
+        message:
+          "Custom sandbox backends are not supported; the agent runs in the session workspace directory. Ignoring.",
+      });
+    }
+  }
+  const workspaceDir = join(sandboxDir, "workspace");
+  if (!(await isDirectory(workspaceDir))) {
+    return [];
+  }
+  const seedFiles: SeedFile[] = [];
+  for (const filePath of await walkFiles(workspaceDir)) {
+    seedFiles.push({
+      relativePath: toPosix(relative(workspaceDir, filePath)),
+      sourcePath: filePath,
+    });
+  }
+  return seedFiles;
+}