@cursor/july 0.1.102 → 0.1.103

package/src/internal/discovery/names.ts

@@ -13,7 +13,7 @@ export const NAME_PATTERN: RegExp = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
  */
 export function validateName(
   ctx: DiscoveryContext,
-  kind: "skill" | "tool" | "extension" | "connection" | "subagent",
+  kind: "skill" | "tool" | "extension" | "connection" | "subagent" | "channel",
   name: string,
   entryPath: string
 ): boolean {
@@ -23,6 +23,7 @@ export function validateName(
     extension: "Extension",
     connection: "MCP connection",
     subagent: "Subagent",
+    channel: "Channel",
   }[kind];
   if (!NAME_PATTERN.test(name)) {
     ctx.diagnostics.push({

package/src/internal/discovery/project.ts

@@ -4,15 +4,23 @@
 
 import { basename, join, resolve } from "node:path";
 import { httpChannel } from "../../channels.js";
-import type { AgentProject, Diagnostic } from "../../types.js";
+import type {
+  AgentProject,
+  ArtifactsDefinition,
+  Diagnostic,
+} from "../../types.js";
 import { registerAuthoredModuleLoaders } from "../authored-loaders.js";
-import { applyAgentContinuationDefaults } from "../continuation-channel.js";
+import {
+  applyAgentContinuationDefaults,
+  warnOmittedContinuationDowngrades,
+} from "../continuation-channel.js";
 import { loadABConfig, loadABs } from "./ab.js";
 import { loadAgent, warnUnknownSlots } from "./agent.js";
 import { loadChannels } from "./channels.js";
 import {
   type DiscoveryContext,
   defaultImportModule,
+  displayPath,
   type LoadAgentProjectOptions,
 } from "./context.js";
 import {
@@ -28,7 +36,9 @@ import {
   appendArtifactTool,
   loadArtifacts,
   loadOtel,
+  loadResult,
   loadStorage,
+  mergeArtifacts,
 } from "./services.js";
 
 /**
@@ -170,11 +180,7 @@ function assertSlug(name: string, parentDir: string): string {
 }
 
 /** URL path segments reserved by the server; agents cannot use them as slugs. */
-export const RESERVED_SLUGS: Set<string> = new Set([
-  "v1",
-  "playground",
-  "docs",
-]);
+const RESERVED_SLUGS: Set<string> = new Set(["v1", "playground", "docs"]);
 
 export async function loadAgentProject(
   dir: string,
@@ -208,7 +214,7 @@ export async function loadAgentProject(
   };
 
   const name = (await readPackageName(rootDir)) ?? basename(rootDir);
-  const agent = await loadAgent(ctx, agentDir, {
+  const { agent, projectSlots } = await loadAgent(ctx, agentDir, {
     name,
     isRoot: true,
   });
@@ -217,13 +223,42 @@ export async function loadAgentProject(
     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 hooks = await loadHooks(ctx, join(agentDir, "hooks"));
+  hooks.push(...projectSlots.hooks);
   const abs = await loadABs(ctx, agentDir);
+  for (const experiment of projectSlots.abs) {
+    if (abs.some((existing) => existing.name === experiment.name)) {
+      ctx.diagnostics.push({
+        severity: "error",
+        path: displayPath(ctx, join(agentDir, "extensions")),
+        message: `Extension A/B experiment "${experiment.name}" collides with an agent experiment.`,
+      });
+      continue;
+    }
+    abs.push(experiment);
+  }
   const abConfig = await loadABConfig(ctx, agentDir);
   const storage = await loadStorage(ctx, agentDir, agent.architecture);
-  const artifacts = await loadArtifacts(ctx, agentDir);
+  const artifacts = await mergeProjectArtifacts(
+    ctx,
+    agentDir,
+    projectSlots.artifacts
+  );
   const otel = await loadOtel(ctx, agentDir);
+  const result = await loadResult(ctx, agentDir);
   await appendArtifactTool(ctx, agentDir, agent, artifacts);
 
   if (agentDir !== rootDir) {
@@ -231,6 +266,17 @@ export async function loadAgentProject(
   }
 
   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,
@@ -250,11 +296,36 @@ export async function loadAgentProject(
     abConfig,
     storage,
     artifacts,
+    result,
     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");

package/src/internal/discovery/runtime.ts

@@ -4,7 +4,6 @@
 
 import { join } from "node:path";
 import type { AgentRuntime } from "../../types.js";
-import { builtinTools } from "../builtin-tools/index.js";
 import { type DiscoveryContext, displayPath } from "./context.js";
 
 /**
@@ -153,7 +152,7 @@ export function warnCloudRuntimeLimitations(
       severity: "warning",
       path: displayPath(ctx, join(agentDir, "sandbox")),
       message:
-        "sandbox/workspace seed files apply to the local session workspace only; cloud agents use the configured cloud repos.",
+        "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

@@ -5,6 +5,7 @@
 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";
@@ -13,7 +14,8 @@ import { importDefault } from "./modules.js";
 
 export async function loadSchedules(
   ctx: DiscoveryContext,
-  schedulesDir: string
+  schedulesDir: string,
+  onDisable?: (name: string, path: string) => void
 ): Promise<DiscoveredSchedule[]> {
   if (!(await isDirectory(schedulesDir))) {
     return [];
@@ -23,6 +25,14 @@ export async function loadSchedules(
     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)) {
@@ -62,10 +72,26 @@ export async function loadSchedules(
       continue;
     }
     const name = rel.slice(0, -extname(rel).length);
-    const definition = await importDefault(ctx, filePath, "schedule");
+    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({

package/src/internal/discovery/services.ts

@@ -1,14 +1,17 @@
 /**
- * `agent/storage.ts`, `agent/otel.ts`, `agent/artifacts.ts`: host services the agent configures.
+ * `agent/storage.ts`, `agent/otel.ts`, `agent/artifacts.ts`,
+ * `agent/result.ts`: host services the agent configures.
  */
 
 import { join } from "node:path";
+import { defineArtifacts } from "../../artifacts.js";
 import type { OtelDefinition } from "../../otel.js";
 import type { StorageDefinition } from "../../storage.js";
 import type {
   AgentArchitecture,
   ArtifactsDefinition,
   ResolvedAgent,
+  ResultDefinition,
 } from "../../types.js";
 import {
   artifactBuiltinTool,
@@ -92,6 +95,39 @@ export async function loadArtifacts(
   return definition;
 }
 
+export async function loadResult(
+  ctx: DiscoveryContext,
+  agentDir: string
+): Promise<ResultDefinition | undefined> {
+  const path = await findModuleFile(agentDir, "result");
+  if (path === undefined) {
+    return undefined;
+  }
+  const imported = await importDefault(ctx, path, "result");
+  if (imported === undefined) {
+    return undefined;
+  }
+  return imported as ResultDefinition;
+}
+
+/** Merge namespaced extension kinds onto the agent's artifacts registry. */
+export function mergeArtifacts(
+  agent: ArtifactsDefinition | undefined,
+  extra: ArtifactsDefinition | undefined
+): ArtifactsDefinition | undefined {
+  if (extra === undefined) {
+    return agent;
+  }
+  if (agent === undefined) {
+    return extra;
+  }
+  return defineArtifacts({
+    kinds: { ...agent.kinds, ...extra.kinds },
+    agentTool: agent.agentTool === true || extra.agentTool === true,
+    max: agent.max ?? extra.max,
+  });
+}
+
 /**
  * Materialize the `tag_artifact` built-in when `defineArtifacts` set
  * `agentTool: true`. Appended after `loadAgent` because the tool is

package/src/internal/discovery/skills.ts

@@ -10,6 +10,7 @@ import type {
   SkillDefinition,
   SkillFileSource,
 } from "../../types.js";
+import { getDefinitionKind } from "../brand.js";
 import { parseFrontmatter } from "../frontmatter.js";
 import { type DiscoveryContext, displayPath, isBlank } from "./context.js";
 import {
@@ -53,7 +54,8 @@ export async function skillFiles(
 
 export async function loadSkills(
   ctx: DiscoveryContext,
-  skillsDir: string
+  skillsDir: string,
+  onDisable?: (name: string, path: string) => void
 ): Promise<DiscoveredSkill[]> {
   if (!(await isDirectory(skillsDir))) {
     return [];
@@ -92,10 +94,18 @@ export async function loadSkills(
       if (!validateName(ctx, "skill", name, entryPath)) {
         continue;
       }
-      const definition = await importDefault(ctx, entryPath, "skill");
+      const definition = await importDefault(
+        ctx,
+        entryPath,
+        onDisable === undefined ? "skill" : ["skill", "disabled"]
+      );
       if (definition === undefined) {
         continue;
       }
+      if (getDefinitionKind(definition) === "disabled") {
+        onDisable?.(name, entryPath);
+        continue;
+      }
       skills.push(compileSkill(name, definition as SkillDefinition));
     }
   }
@@ -156,7 +166,7 @@ async function loadPackagedSkill(
  * Advertise the first non-empty, non-code-fence line of the body, with any
  * leading `#`, `>`, `*`, or `-` markers stripped.
  */
-export function deriveSkillDescription(markdown: string): string | undefined {
+function deriveSkillDescription(markdown: string): string | undefined {
   let inFence = false;
   for (const rawLine of markdown.split(/\r?\n/)) {
     const line = rawLine.trim();

package/src/internal/discovery/subagent.ts

@@ -2,8 +2,14 @@
  * A subagent as the Cursor harness runs it: description, model, and prompt. Its other slots are inert.
  */
 
+import { join } from "node:path";
 import type { ModelSetting, ResolvedAgent } from "../../types.js";
 import { withIdentityPreamble } from "../workspace.js";
+import { loadAgentConfig } from "./agent-config.js";
+import { type DiscoveryContext, displayPath } from "./context.js";
+import { findModuleFile, isDirectory, sortedEntries } from "./fs.js";
+import { loadInstructions } from "./instructions.js";
+import { validateName } from "./names.js";
 
 interface SubagentFields {
   description?: string;
@@ -27,3 +33,104 @@ export function subagent(name: string, fields: SubagentFields): ResolvedAgent {
     seedFiles: [],
   };
 }
+
+export async function loadSubagents(
+  ctx: DiscoveryContext,
+  subagentsDir: string
+): Promise<ResolvedAgent[]> {
+  if (!(await isDirectory(subagentsDir))) {
+    return [];
+  }
+  const subagents: ResolvedAgent[] = [];
+  for (const entry of await sortedEntries(subagentsDir)) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const subagentDir = join(subagentsDir, entry.name);
+    if (!validateName(ctx, "subagent", entry.name, subagentDir)) {
+      continue;
+    }
+    subagents.push(await loadSubagent(ctx, subagentDir, entry.name));
+  }
+  return subagents;
+}
+
+export async function loadSubagent(
+  ctx: DiscoveryContext,
+  agentDir: string,
+  name: string
+): Promise<ResolvedAgent> {
+  const config = await loadAgentConfig(ctx, agentDir, false);
+  const prompt = await loadInstructions(ctx, agentDir, config, false);
+  await warnUnsupportedSubagentSlots(ctx, agentDir);
+  if (config?.builtinTools !== undefined) {
+    ctx.diagnostics.push({
+      severity: "warning",
+      path: displayPath(ctx, join(agentDir, "agent.ts")),
+      message: "builtinTools is not supported on subagents; ignoring.",
+    });
+  }
+  if (config?.tools !== undefined) {
+    ctx.diagnostics.push({
+      severity: "warning",
+      path: displayPath(ctx, join(agentDir, "agent.ts")),
+      message:
+        "tools is not supported on subagents (they keep the harness task-tool toolset); ignoring.",
+    });
+  }
+  if (config?.architecture !== undefined) {
+    ctx.diagnostics.push({
+      severity: "warning",
+      path: displayPath(ctx, join(agentDir, "agent.ts")),
+      message: "architecture is not supported on subagents; ignoring.",
+    });
+  }
+  const artifactsPath = await findModuleFile(agentDir, "artifacts");
+  if (artifactsPath !== undefined) {
+    ctx.diagnostics.push({
+      severity: "warning",
+      path: displayPath(ctx, artifactsPath),
+      message: "artifacts are not supported on subagents; ignoring.",
+    });
+  }
+  const resultPath = await findModuleFile(agentDir, "result");
+  if (resultPath !== undefined) {
+    ctx.diagnostics.push({
+      severity: "warning",
+      path: displayPath(ctx, resultPath),
+      message: "result is not supported on subagents; ignoring.",
+    });
+  }
+  return subagent(config?.name ?? name, {
+    description: config?.description,
+    model: config?.model,
+    prompt,
+  });
+}
+
+async function warnUnsupportedSubagentSlots(
+  ctx: DiscoveryContext,
+  subagentDir: string
+): Promise<void> {
+  const unsupported = [
+    ["tools", "tools"],
+    ["skills", "skills"],
+    ["extensions", "extensions"],
+    ["mcp-connections", "MCP connections"],
+    ["host-connections", "host MCP connections"],
+    ["subagents", "nested subagents"],
+    ["channels", "channels"],
+    ["schedules", "schedules"],
+    ["hooks", "hooks"],
+    ["sandbox", "sandbox files"],
+  ] as const;
+  for (const [slot, label] of unsupported) {
+    if (await isDirectory(join(subagentDir, slot))) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        path: displayPath(ctx, join(subagentDir, slot)),
+        message: `Subagent ${label} are not supported on the Cursor harness yet; the subagent runs with the parent's execution surface. Ignoring.`,
+      });
+    }
+  }
+}

package/src/internal/discovery.ts

@@ -20,7 +20,5 @@ export {
   listChildAgentDirs,
   loadAgentProject,
   loadAgentProjects,
-  RESERVED_SLUGS,
   resolveAgentMounts,
 } from "./discovery/project.js";
-export { deriveSkillDescription } from "./discovery/skills.js";

package/src/internal/distribution.ts

@@ -2,31 +2,18 @@
  * Distribution facts for the running copy of the framework.
  *
  * The package publishes to npm as `@cursor/july` (the pre-launch codename
- * for Agent SDK; bins: `july` for `npx @cursor/july`, `agent-sdk`, the
- * older `agentkit`, and the legacy `agent-serve` alias) but
- * the monorepo keeps its historical `@anysphere/agent-serve` import name
- * working via tsconfig paths (source runs) and the runtime alias hooks
- * (compiled runs). Everything that needs to print a package name, print a
- * CLI command, or locate the package root goes through this module.
+ * for Agent SDK) with one bin, `agent-sdk`. Everything that needs to print
+ * a package name, print a CLI command, locate the package root, or pin
+ * `@cursor/july[/x]` to this copy goes through this module.
  */
 
 import { readFileSync } from "node:fs";
-import { basename } from "node:path";
-import { fileURLToPath } from "node:url";
+import { join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
 
 /** Published npm package name (pre-launch codename for Agent SDK). */
 export const PACKAGE_NAME = "@cursor/july";
 
-/** Historical monorepo package name; never published, aliased at runtime. */
-export const LEGACY_PACKAGE_NAME = "@anysphere/agent-serve";
-
-/**
- * Future public package name; aliased with the same direct-to-running-dist
- * semantics as PACKAGE_NAME so the eventual rename keeps authored imports
- * on the CLI's module identity.
- */
-export const AGENTKIT_PACKAGE_NAME = "@cursor/agentkit";
-
 /**
  * Bracketed product tag for stderr / ServeOptions.logger lines
  * (`[agent-sdk] …`, `[agent-sdk/slack] …`).
@@ -35,23 +22,8 @@ export const LOG_PRODUCT = "agent-sdk";
 export const LOG_PREFIX: string = `[${LOG_PRODUCT}]`;
 export const SLACK_LOG_PREFIX: string = `[${LOG_PRODUCT}/slack]`;
 
-/**
- * Command name this CLI was invoked as. Both bins point at the same entry;
- * keep help text and hints copy-pasteable for whichever the user typed.
- */
-export const CLI_COMMAND_NAME: string = detectCliCommandName();
-
-function detectCliCommandName(): string {
-  // Only an extensionless `agent-serve` entry (the npm .bin symlink) proves
-  // the user typed the legacy alias. Shims that re-exec the real dist script
-  // (pnpm/Windows) hand us `agent-serve.js` for both bins, so anything else
-  // brands as the primary name.
-  const entry = process.argv[1];
-  if (entry !== undefined && basename(entry) === "agent-serve") {
-    return "agent-serve";
-  }
-  return "agent-sdk";
-}
+/** The bin name, for help text and copy-pasteable hints. */
+export const CLI_COMMAND_NAME = "agent-sdk";
 
 /**
  * True when this module runs from compiled `dist/` output (a published
@@ -72,14 +44,19 @@ export function packageRootDir(): string {
   return fileURLToPath(new URL("../..", import.meta.url));
 }
 
+interface PackageManifest {
+  version: string;
+  exports: Record<string, { import: string }>;
+}
+
+function packageManifest(): PackageManifest {
+  const raw = readFileSync(join(packageRootDir(), "package.json"), "utf8");
+  return JSON.parse(raw) as PackageManifest;
+}
+
 /** Version of the running package (from its own package.json). */
 export function packageVersion(): string {
-  const raw = readFileSync(
-    new URL("../../package.json", import.meta.url),
-    "utf8"
-  );
-  const parsed = JSON.parse(raw) as { version?: unknown };
-  return typeof parsed.version === "string" ? parsed.version : "0.0.0";
+  return packageManifest().version;
 }
 
 /** Facts `agent-sdk version` / `--version` print. */
@@ -88,15 +65,12 @@ export interface CliVersionInfo {
   name: string;
   /** `package.json` version of this install. */
   version: string;
-  /** Bin the process was invoked as (`agent-sdk` / `agent-serve`). */
-  cli: string;
 }
 
 export function cliVersionInfo(): CliVersionInfo {
   return {
     name: PACKAGE_NAME,
     version: packageVersion(),
-    cli: CLI_COMMAND_NAME,
   };
 }
 
@@ -114,43 +88,21 @@ export function formatCliVersion(options?: { json?: boolean }): string {
 }
 
 /**
- * Authoring entry subpaths and their dist-relative output files — the
- * runtime mirror of the package `exports` map (the source of truth;
- * `authored-loaders.test.ts` asserts they stay identical). The alias hooks
- * derive `@anysphere/agent-serve[/x]`, `@cursor/july[/x]`, and
- * `@cursor/agentkit[/x]` direct targets from this list.
+ * `@cursor/july[/subpath]` → `file:` URL of this copy's `import` target,
+ * for every subpath in the package `exports` map. The published manifest
+ * points at `dist/`; Bazel's staged copy points at the in-place `src/`
+ * emit, and the aliases follow whichever the manifest says.
  */
-export const AUTHORING_ENTRY_FILES: ReadonlyArray<
-  readonly [subpath: string, file: string]
-> = [
-  ["", "index.js"],
-  ["tools", "tools.js"],
-  ["channels", "channels.js"],
-  ["channels/slack", "channels/slack/index.js"],
-  ["channels/github", "channels/github/index.js"],
-  ["channels/origin", "channels/origin/index.js"],
-  ["channels/deployments", "channels/deployments/index.js"],
-  ["skills", "skills.js"],
-  ["extensions", "extensions.js"],
-  [
-    "extensions/cursor-cloud-agents",
-    "extensions/cursor-cloud-agents/extension.js",
-  ],
-  ["schedules", "schedules.js"],
-  ["reminders", "reminders.js"],
-  ["connections", "connections.js"],
-  ["hooks", "hooks.js"],
-  ["memory", "memory.js"],
-  ["prompt", "prompt.js"],
-  ["evals", "evals.js"],
-  ["evals/reporters", "evals/reporters.js"],
-  ["evals/loaders", "evals/loaders.js"],
-  ["ab", "ab.js"],
-  ["artifacts", "artifacts.js"],
-  ["kv", "kv.js"],
-  ["kv/memory", "kv/memory-kv.js"],
-  ["storage", "storage.js"],
-  ["storage/file-kv", "storage-backends/file-kv.js"],
-  ["storage/cursor-hosted", "storage-backends/cursor-hosted.js"],
-  ["otel", "otel.js"],
-];
+export function frameworkAliases(): Record<string, string> {
+  const root = packageRootDir();
+  return Object.fromEntries(
+    Object.entries(packageManifest().exports).map(
+      ([exportPath, { import: file }]) => [
+        exportPath === "."
+          ? PACKAGE_NAME
+          : `${PACKAGE_NAME}/${exportPath.slice(2)}`,
+        pathToFileURL(join(root, file)).href,
+      ]
+    )
+  );
+}

package/src/internal/docs-site.ts

@@ -245,7 +245,7 @@ function fallbackHtml(): string {
   <head>
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>agent-serve docs</title>
+    <title>agent-sdk docs</title>
     <style>
       body { margin: 0; background: #0e1116; color: #e6edf3; font: 14px/1.6 ui-sans-serif, system-ui, sans-serif; }
       .box { max-width: 640px; margin: 64px auto; padding: 0 24px; }

package/src/internal/eval-run-store.ts

@@ -23,13 +23,6 @@ import {
   runDiscoveredEvals,
 } from "./eval-runner.js";
 
-export type {
-  EvalBatchStatus,
-  EvalCaseRunStatus as EvalCaseStatus,
-  EvalCaseSnapshot,
-  EvalRunSnapshot,
-} from "../evals.js";
-
 /**
  * Durable mirror for playground eval batches — the `StorageCoordinator`
  * adapter over the `defineStorage` `evals` table. Writes are