@cursor/july 0.1.108 → 0.1.109

package/src/channels/gitlab/api.ts

@@ -92,6 +92,35 @@ export interface GitLabClient {
   request<T = unknown>(input: GitLabRequestInput): Promise<T>;
 }
 
+export interface GitLabApiMergeRequest {
+  iid: number;
+  title?: string;
+  description?: string;
+  state?: string;
+  draft?: boolean;
+  webUrl?: string;
+  headSha?: string;
+  sourceBranch?: string;
+  targetBranch?: string;
+  authorUsername?: string;
+  baseSha?: string;
+  changedFilesCount?: number;
+}
+
+export interface GitLabApiMergeRequestDiff {
+  oldPath: string;
+  newPath: string;
+  patch?: string;
+  status: "added" | "modified" | "removed" | "renamed";
+}
+
+/** Project-bound merge-request reads shared by GitLab agents. */
+export interface GitLabApi {
+  getMergeRequest(iid: number): Promise<GitLabApiMergeRequest>;
+  getMergeBaseSha(base: string, headSha: string): Promise<string | undefined>;
+  listMergeRequestDiffs(iid: number): Promise<GitLabApiMergeRequestDiff[]>;
+}
+
 function envValue(value: string | undefined): string | undefined {
   const trimmed = value?.trim();
   return trimmed === undefined || trimmed === "" ? undefined : trimmed;
@@ -136,6 +165,100 @@ export function gitlabProjectPathSegment(project: number | string): string {
     : encodeURIComponent(project.replace(/^\/+|\/+$/g, ""));
 }
 
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+function nonEmptyString(value: unknown): string | undefined {
+  return typeof value === "string" && value !== "" ? value : undefined;
+}
+
+const GITLAB_DIFFS_PER_PAGE = 100;
+
+export function createGitLabApi(
+  client: Pick<GitLabClient, "request">,
+  project: number | string
+): GitLabApi {
+  const projectPath = `/projects/${gitlabProjectPathSegment(project)}`;
+  return {
+    async getMergeRequest(iid) {
+      const raw = await client.request<Record<string, unknown>>({
+        method: "GET",
+        path: `${projectPath}/merge_requests/${iid}`,
+      });
+      const diffRefs = asRecord(raw.diff_refs);
+      const changesCount = nonEmptyString(raw.changes_count);
+      return {
+        iid: (raw.iid as number | null | undefined) ?? iid,
+        title: raw.title as string | undefined,
+        description:
+          raw.description === null
+            ? undefined
+            : (raw.description as string | undefined),
+        state: raw.state as string | undefined,
+        draft:
+          typeof raw.draft === "boolean"
+            ? raw.draft
+            : typeof raw.work_in_progress === "boolean"
+              ? raw.work_in_progress
+              : undefined,
+        webUrl: raw.web_url as string | undefined,
+        headSha:
+          (raw.sha as string | null | undefined) ??
+          (diffRefs?.head_sha as string | undefined),
+        sourceBranch: raw.source_branch as string | undefined,
+        targetBranch: raw.target_branch as string | undefined,
+        authorUsername: asRecord(raw.author)?.username as string | undefined,
+        baseSha: nonEmptyString(diffRefs?.base_sha),
+        changedFilesCount:
+          changesCount !== undefined && /^\d+$/.test(changesCount)
+            ? Number(changesCount)
+            : undefined,
+      };
+    },
+    async getMergeBaseSha(base, headSha) {
+      const data = await client.request<{ id?: string }>({
+        method: "GET",
+        path: `${projectPath}/repository/merge_base?refs[]=${encodeURIComponent(base)}&refs[]=${encodeURIComponent(headSha)}`,
+      });
+      return nonEmptyString(data.id);
+    },
+    async listMergeRequestDiffs(iid) {
+      const files: GitLabApiMergeRequestDiff[] = [];
+      for (let page = 1; ; page += 1) {
+        const diffs = await client.request<Record<string, unknown>[]>({
+          method: "GET",
+          path: `${projectPath}/merge_requests/${iid}/diffs`,
+          query: { page, per_page: GITLAB_DIFFS_PER_PAGE },
+        });
+        for (const diff of diffs) {
+          const status =
+            diff.new_file === true
+              ? "added"
+              : diff.deleted_file === true
+                ? "removed"
+                : diff.renamed_file === true
+                  ? "renamed"
+                  : "modified";
+          const rawPatch =
+            typeof diff.diff === "string" ? diff.diff : undefined;
+          files.push({
+            oldPath: diff.old_path as string,
+            newPath: diff.new_path as string,
+            status,
+            patch: rawPatch?.replace(/\n$/, ""),
+          });
+        }
+        if (diffs.length < GITLAB_DIFFS_PER_PAGE) {
+          return files;
+        }
+      }
+    },
+  };
+}
+
 function buildQuery(query: GitLabRequestInput["query"]): string {
   if (query === undefined) {
     return "";

package/src/channels/gitlab/binding.ts

@@ -176,6 +176,18 @@ export function gitlabMergeRequestUrl(
   return explicit ?? `${project.webUrl}/-/merge_requests/${iid}`;
 }
 
+/**
+ * Whether an `update` payload marks a draft merge request ready. GitLab uses
+ * either `changes.draft` or the legacy `changes.work_in_progress` shape.
+ */
+export function gitlabDraftMarkedReady(
+  payload: Record<string, unknown>
+): boolean {
+  const changes = asRecord(payload.changes);
+  const draft = asRecord(changes?.draft ?? changes?.work_in_progress);
+  return draft?.current === false && draft.previous !== false;
+}
+
 /** Normalize a merge-request record (`object_attributes` or `merge_request`). */
 export function gitlabMergeRequestFromRecord(
   project: GitLabProjectRef,

package/src/channels/gitlab/index.ts

@@ -22,6 +22,7 @@ export * from "./api.js";
 export {
   buildGitLabBinding,
   type GitLabHandle,
+  gitlabDraftMarkedReady,
   gitlabMergeRequestFromRecord,
   gitlabMergeRequestUrl,
   gitlabProjectFromPayload,

package/src/channels/slack/dispatch.ts

@@ -8,6 +8,7 @@ import {
   type MailboxContinuation,
   normalizeIdentity,
 } from "../../internal/continuation-identity.js";
+import { isDeferredChannelSession } from "../../internal/deferred-channel-session.js";
 import { routeLocalIngressContinuation } from "../../internal/local-ingress.js";
 import { steeringEnabled } from "../../internal/steering.js";
 import type {
@@ -189,6 +190,14 @@ export interface SlackInboundDispatchDeps extends SlackContinuationProbes {
    */
   suggestedPrompts?: SlackSuggestedPrompt[];
   suggestedPromptsTitle?: string;
+  /**
+   * Rethrow handler failures out of the dispatch promise instead of
+   * swallowing them after the error log. Hosted admission sets this so a
+   * throwing handler rejects `waitUntil` and surfaces as a retryable 503
+   * to the control plane (matching the GitHub/Origin adapters); the
+   * long-lived Socket Mode loop keeps the swallow-and-log default.
+   */
+  propagateHandlerErrors?: boolean;
 }
 
 function triggeringMergeMessage(
@@ -267,6 +276,8 @@ export async function dispatchInboundMessage(args: {
   followUpStatus?: boolean;
   blockExternals?: boolean;
   continuation?: ContinuationIdentity;
+  /** See {@link SlackInboundDispatchDeps.propagateHandlerErrors}. */
+  propagateHandlerErrors?: boolean;
 }): Promise<void> {
   const { message, kind } = args;
   const log = args.log ?? defaultSlackLog;
@@ -399,6 +410,9 @@ export async function dispatchInboundMessage(args: {
       thread_ts: message.threadTs,
       event_id: args.eventId,
     });
+    if (args.propagateHandlerErrors === true) {
+      throw error;
+    }
     return;
   }
   if (decision === null || decision === undefined) {
@@ -527,6 +541,19 @@ export async function dispatchInboundMessage(args: {
 
   try {
     const session = await args.send(prompt, sendOptions);
+    if (isDeferredChannelSession(session)) {
+      // Hosted admission captured the send; the control plane allocates
+      // the session and runs the turn only after this delivery is
+      // acknowledged, so there is nothing to observe or coalesce yet.
+      log.info("session send captured (hosted admission)", {
+        kind,
+        continuation,
+        channel: message.channelId,
+        thread_ts: message.threadTs,
+        event_id: args.eventId,
+      });
+      return;
+    }
     log.info(
       session.coalesced === true ? "session coalesced" : "session start",
       {
@@ -659,6 +686,7 @@ export function dispatchInboundFromEventBody(
         kind: "app_mention",
         message: mention,
         handler: deps.onAppMention,
+        propagateHandlerErrors: deps.propagateHandlerErrors,
         send: deps.send,
         credentials: deps.credentials,
         host: deps.host,
@@ -702,6 +730,7 @@ export function dispatchInboundFromEventBody(
         kind: "direct_message",
         message: dm,
         handler: deps.onDirectMessage,
+        propagateHandlerErrors: deps.propagateHandlerErrors,
         send: deps.send,
         credentials: deps.credentials,
         host: deps.host,
@@ -739,6 +768,7 @@ export function dispatchInboundFromEventBody(
         kind: "reaction_added",
         message: reaction,
         handler: deps.onReactionAdded,
+        propagateHandlerErrors: deps.propagateHandlerErrors,
         send: deps.send,
         credentials: deps.credentials,
         host: deps.host,

package/src/channels/slack/slack-channel.ts

@@ -1,17 +1,29 @@
 /**
- * `slackChannel()` — platform channel pack for Slack (Socket Mode).
+ * `slackChannel()` — platform channel pack for Slack.
  *
- * Inbound events arrive over a WebSocket (`SLACK_APP_TOKEN`); no public
- * Request URL or Events HTTP route is required. When `toolApprovals`
- * is enabled, Approve/Deny buttons arrive as Socket Mode `interactive`
- * envelopes.
+ * Local / self-hosted transport is Socket Mode: inbound events arrive over
+ * a WebSocket (`SLACK_APP_TOKEN`); no public Request URL or Events HTTP
+ * route is required. When `toolApprovals` is enabled, Approve/Deny buttons
+ * arrive as Socket Mode `interactive` envelopes.
+ *
+ * Hosted v2 transport is the control plane's Events API ingest: the CP
+ * verifies the managed app's signature, fans out on the declared
+ * `slackEventTypes` (`app_mention`, `message`), and delivers the full
+ * `event_callback` body through hosted admission — the attached adapter
+ * routes it through the same inbound dispatch as Socket Mode. Without an
+ * app token the socket transport idles, so a hosted pod never needs one.
  */
 
 import { allowAll, defineChannel } from "../../channels.js";
+import {
+  skipped,
+  withPropagatingBackgroundErrors,
+} from "../../internal/channel-dispatch.js";
 import {
   continuationSource,
   normalizeIdentity,
 } from "../../internal/continuation-identity.js";
+import { attachHostedAdmissionAdapter } from "../../internal/hosted-admission-adapter.js";
 import type {
   ArtifactsApi,
   ChannelDefinition,
@@ -51,7 +63,7 @@ import {
   emptySlackChannelState,
   type SlackInboundDispatchDeps,
 } from "./dispatch.js";
-import { createEventIdDedupe } from "./event-id-dedupe.js";
+import { createEventIdDedupe, type EventIdDedupe } from "./event-id-dedupe.js";
 import {
   dispatchBlockAction,
   dispatchInteractiveFromPayload,
@@ -159,6 +171,18 @@ export function slackChannel(
     normalizeBotMentionAllowlist(botMentions.allowFrom);
   }
   const eventIds = createEventIdDedupe();
+  // Hosted v2 event capability, matching what the engagement flags can
+  // dispatch: mentions ride `app_mention`; DMs and watched channel posts
+  // both arrive as `message`. Membership of `slack.thread/v2` admits
+  // exactly these two, so `reaction_added` (hosted follow-up only inside
+  // an existing thread) is deliberately not declared.
+  const slackEventTypes: string[] = [];
+  if (mentionsEnabled) {
+    slackEventTypes.push("app_mention");
+  }
+  if (directMessagesEnabled || channelPosts !== undefined) {
+    slackEventTypes.push("message");
+  }
   const toolApprovals = options.toolApprovals === true;
   const interactivity = options.interactivity === true;
   const onBlockAction = options.onBlockAction;
@@ -201,6 +225,9 @@ export function slackChannel(
     waitUntil: (promise: Promise<unknown>) => void;
     host: HostContext;
     artifacts: ArtifactsApi;
+    /** Override the channel-level dedupe (hosted admission passes a fresh one). */
+    eventIds?: EventIdDedupe;
+    propagateHandlerErrors?: boolean;
     hasContinuationSession?: (continuationToken: string) => Promise<boolean>;
     isContinuationBusy?: (continuationToken: string) => Promise<boolean>;
     getContinuationLastBotMessageTs?: (
@@ -216,7 +243,8 @@ export function slackChannel(
       onDirectMessage,
       ...(onReactionAdded === undefined ? {} : { onReactionAdded }),
       credentials,
-      eventIds,
+      eventIds: args.eventIds ?? eventIds,
+      propagateHandlerErrors: args.propagateHandlerErrors,
       host: args.host,
       artifacts: args.artifacts,
       log: getLog(),
@@ -253,6 +281,10 @@ export function slackChannel(
     routes: [],
     meta: {
       kind: "slack",
+      // Omitted (not empty) when nothing dispatches, so fanout never
+      // materializes a subscription with no event types.
+      slackEventTypes:
+        slackEventTypes.length === 0 ? undefined : slackEventTypes,
       ...(channelPosts === undefined
         ? {}
         : { slackChannelPosts: [...channelPosts.allow] }),
@@ -551,6 +583,36 @@ export function slackChannel(
   });
 
   slackChannelOptionsByDefinition.set(definition, options);
+  attachHostedAdmissionAdapter(definition, {
+    kind: "slack",
+    prepareArgs: withPropagatingBackgroundErrors,
+    // The payload is the full `event_callback` body the CP verified — the
+    // same shape Socket Mode unwraps — so it routes through the same
+    // inbound dispatch. Outcomes: a captured `send` overrides the fallback
+    // tag below, so `skipped` surfaces when the engagement rules declined
+    // (`not_engaged`) or no handler takes the shape (`not_dispatchable`);
+    // a throwing handler rejects `waitUntil` (propagateHandlerErrors) and
+    // hosted admission answers a retryable 503, like the PR adapters.
+    // The channel-level event_id dedupe is deliberately bypassed with a
+    // fresh instance per delivery: the control plane's app-scoped ingress
+    // claim already dedupes Slack retries, and on a warm pod the local set
+    // would otherwise swallow the control plane's own retry of a delivery
+    // that failed after the id was marked handled.
+    dispatch: async ({ payload, args }) => {
+      const dispatched = dispatchInboundFromEventBody(
+        payload,
+        inboundDeps({
+          send: args.send,
+          waitUntil: args.waitUntil,
+          host: args.host,
+          artifacts: args.artifacts,
+          eventIds: createEventIdDedupe(),
+          propagateHandlerErrors: true,
+        })
+      );
+      return skipped(dispatched ? "not_engaged" : "not_dispatchable");
+    },
+  });
 
   return definition;
 }

package/src/extensions.ts

@@ -4,8 +4,8 @@
  * An extension is a directory laid out like `agent/`: `extension.ts`
  * declares it; `tools/`, `skills/`, `mcp-connections/`,
  * `host-connections/`, `hooks/`, `channels/`, `schedules/`,
- * `subagents/`, `instructions`, `ab.ts` / `ab/`, `artifacts.ts`,
- * and `sandbox/workspace/` are its contributions. `lib/` holds
+ * `subagents/`, `instructions`, `artifacts.ts`, and
+ * `sandbox/workspace/` are its contributions. `lib/` holds
  * shared code.
  *
  * ```ts
@@ -162,10 +162,6 @@ export function disableInstructions(): DisabledDefinition {
   return disable();
 }
 
-export function disableAB(): DisabledDefinition {
-  return disable();
-}
-
 export function disableArtifacts(): DisabledDefinition {
   return disable();
 }

package/src/index.ts

@@ -31,7 +31,6 @@ import type {
   ServeOptions,
 } from "./types.js";
 
-export { defineAB } from "./ab.js";
 export { defineArtifacts } from "./artifacts.js";
 // Authoring helpers (also available on their focused subpath exports).
 export {
@@ -55,7 +54,6 @@ export {
   cursorPlugin,
   defineExtension,
   disable,
-  disableAB,
   disableArtifacts,
   disableChannel,
   disableConnection,
@@ -190,7 +188,6 @@ export { defineSkill } from "./skills.js";
 export type {
   DurableSessionRecord,
   DurableSessionSummary,
-  StorageABTable,
   StorageCasTable,
   StorageConfig,
   StorageContext,

package/src/internal/authored-alias-hooks.ts

@@ -20,10 +20,16 @@
 // Null-prototype copies so specifiers like "constructor" or "__proto__"
 // can never resolve to inherited Object.prototype members.
 let directAliases = toNullProtoMap({});
+let sourceFallbackAliases = toNullProtoMap({});
 let sourceTreeFallbackParentURL: string | undefined;
 
 export interface AuthoredAliasHookData {
   directAliases: Record<string, string>;
+  /**
+   * Framework exports omitted from the running distribution. Resolve these
+   * against an authored project's `anysphere-source` package condition.
+   */
+  sourceFallbackAliases?: string[];
   /**
    * `file:` URL of the running `@cursor/july` package.json. Bare imports
    * from monorepo `packages/agent-serve/` source retry against this parent
@@ -40,6 +46,11 @@ function toNullProtoMap(
 
 export function initialize(data: AuthoredAliasHookData): void {
   directAliases = toNullProtoMap(data.directAliases);
+  sourceFallbackAliases = toNullProtoMap(
+    Object.fromEntries(
+      (data.sourceFallbackAliases ?? []).map((specifier) => [specifier, "1"])
+    )
+  );
   const parent = data.sourceTreeFallbackParentURL;
   sourceTreeFallbackParentURL =
     typeof parent === "string" && parent !== "" ? parent : undefined;
@@ -65,6 +76,9 @@ export function resolve(
   if (direct !== undefined) {
     return { url: direct, shortCircuit: true };
   }
+  if (sourceFallbackAliases[specifier] !== undefined) {
+    return nextResolve(specifier, withCondition(context, "anysphere-source"));
+  }
   if (
     sourceTreeFallbackParentURL !== undefined &&
     isBarePackageSpecifier(specifier) &&
@@ -95,6 +109,24 @@ function withParentURL(context: unknown, parentURL: string): unknown {
   return { parentURL };
 }
 
+function withCondition(context: unknown, condition: string): unknown {
+  const record =
+    context !== null && typeof context === "object"
+      ? (context as Record<string, unknown>)
+      : {};
+  const conditions = Array.isArray(record["conditions"])
+    ? record["conditions"].filter(
+        (value): value is string => typeof value === "string"
+      )
+    : [];
+  return {
+    ...record,
+    conditions: conditions.includes(condition)
+      ? conditions
+      : [...conditions, condition],
+  };
+}
+
 function isBarePackageSpecifier(specifier: string): boolean {
   if (specifier.length === 0) {
     return false;

package/src/internal/authored-loaders.ts

@@ -18,10 +18,11 @@
  * tsconfig paths already cover them.
  */
 
+import { existsSync } from "node:fs";
 import { stat } from "node:fs/promises";
 import { register as registerModuleHooks } from "node:module";
 import { join } from "node:path";
-import { pathToFileURL } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import type { AuthoredAliasHookData } from "./authored-alias-hooks.js";
 import {
   CLI_COMMAND_NAME,
@@ -61,6 +62,22 @@ export function authoredModuleSpecifier(
   return url.href;
 }
 
+export function partitionFrameworkAliases(aliases: Record<string, string>): {
+  directAliases: Record<string, string>;
+  sourceFallbackAliases: string[];
+} {
+  const directAliases: Record<string, string> = {};
+  const sourceFallbackAliases: string[] = [];
+  for (const [specifier, url] of Object.entries(aliases)) {
+    if (existsSync(fileURLToPath(url))) {
+      directAliases[specifier] = url;
+    } else {
+      sourceFallbackAliases.push(specifier);
+    }
+  }
+  return { directAliases, sourceFallbackAliases };
+}
+
 /**
  * Dynamically import an authored TypeScript/JavaScript module, re-reading it
  * from disk when the file's mtime has changed since the last import.
@@ -165,8 +182,15 @@ function registerFrameworkAliases(): void {
     return;
   }
   const hooksUrl = new URL("./authored-alias-hooks.js", import.meta.url);
+  const { directAliases, sourceFallbackAliases } = partitionFrameworkAliases(
+    frameworkAliases()
+  );
   const data: AuthoredAliasHookData = {
-    directAliases: frameworkAliases(),
+    directAliases,
+    // Internal-only exports stay out of the public package. When one is
+    // mounted by an agent in this source checkout, resolve that one import
+    // through the checkout's `anysphere-source` export instead.
+    sourceFallbackAliases,
     // Hosted factory agents relative-import this package's src/ from a
     // monorepo checkout while npm install ran only in the agent directory.
     // Bare specifiers from that tree retry against this package.json.

package/src/internal/cli-ax.ts

@@ -3,8 +3,7 @@
  *   init / run / trajectory / eval
  *
  * Coding agents get JSON-first output, ephemeral local servers, and
- * filesystem-first evals under evals/ (*.eval.ts). Live A/B metrics
- * (`defineAB` under `agent/ab`) plug into serve — there is no `ab` CLI.
+ * filesystem-first evals under evals/ (*.eval.ts).
  */
 
 import { mkdir, mkdtemp, writeFile } from "node:fs/promises";

package/src/internal/continuation-channel.ts

@@ -222,7 +222,8 @@ export function channelDeclaredEventTypes(
     meta?.gitlabWebhookEvents ??
     meta?.bitbucketWebhookEvents ??
     meta?.deploymentEventTypes ??
-    meta?.factoryEventTypes
+    meta?.factoryEventTypes ??
+    meta?.slackEventTypes
   );
 }
 

package/src/internal/continuation-identity.ts

@@ -787,14 +787,22 @@ function extractSlack(payload: unknown): string | undefined {
   if (record === undefined) {
     return undefined;
   }
+  // Events-API deliveries are the full event_callback body, so the
+  // identity fields live under `event`. Top-level fields still win for
+  // pre-flattened payloads (Socket Mode local dev, tests). Keep in
+  // lockstep with the control-plane twin (SlackThreadExtractor).
+  const event = asRecord(record.event);
   const channelId =
     nonEmpty(record.channelId) ??
     nonEmpty(record.channel_id) ??
-    nonEmpty(record.channel);
+    nonEmpty(record.channel) ??
+    nonEmpty(event?.channel);
   const threadTs =
     nonEmpty(record.threadTs) ??
     nonEmpty(record.thread_ts) ??
-    nonEmpty(record.ts);
+    nonEmpty(event?.thread_ts) ??
+    nonEmpty(record.ts) ??
+    nonEmpty(event?.ts);
   if (channelId === undefined || threadTs === undefined) {
     return undefined;
   }

package/src/internal/discovery/agent.ts

@@ -12,7 +12,6 @@ import {
 import {
   type ArtifactsDefinition,
   DEFAULT_MODEL,
-  type DiscoveredAB,
   type DiscoveredChannel,
   type DiscoveredHook,
   type DiscoveredSchedule,
@@ -50,7 +49,7 @@ export interface LoadedRootAgent {
   agent: ResolvedAgent;
   projectSlots: Pick<
     ExtensionContributions,
-    "hooks" | "channels" | "schedules" | "abs" | "artifacts"
+    "hooks" | "channels" | "schedules" | "artifacts"
   >;
 }
 
@@ -66,7 +65,6 @@ export async function loadAgent(
         hooks: [],
         channels: [],
         schedules: [],
-        abs: [],
         artifacts: undefined,
       },
     };
@@ -92,7 +90,6 @@ export async function loadAgent(
   const hooks: DiscoveredHook[] = [];
   const channels: DiscoveredChannel[] = [];
   const schedules: DiscoveredSchedule[] = [];
-  const abs: DiscoveredAB[] = [];
   const instructionParts: string[] = [];
   const contributions = {
     tools,
@@ -105,7 +102,6 @@ export async function loadAgent(
     schedules,
     instructionParts,
     seedFiles,
-    abs,
     artifacts: undefined as ArtifactsDefinition | undefined,
   };
   const extensions = await appendExtensions(
@@ -351,7 +347,6 @@ export async function loadAgent(
       hooks,
       channels,
       schedules,
-      abs,
       artifacts: contributions.artifacts,
     },
   };
@@ -374,7 +369,6 @@ export async function warnUnknownSlots(
     "schedules",
     "reminders",
     "hooks",
-    "ab",
     "sandbox",
     "lib",
     // Vite playground custom tool chips (agent/playground/tools).

package/src/internal/discovery/extension-overlay.ts

@@ -6,7 +6,6 @@
 import { join } from "node:path";
 import type {
   ArtifactsDefinition,
-  DiscoveredAB,
   DiscoveredChannel,
   DiscoveredHook,
   DiscoveredSchedule,
@@ -14,7 +13,6 @@ import type {
   ResolvedAgent,
 } from "../../types.js";
 import { getDefinitionKind } from "../brand.js";
-import { loadABs } from "./ab.js";
 import { loadChannels } from "./channels.js";
 import { type DiscoveryContext, displayPath, errorMessage } from "./context.js";
 import {
@@ -202,22 +200,6 @@ export async function overlayInstructionsFragment(
   return loadInstructions(ctx, overlayDir, undefined, false);
 }
 
-export async function overlayAbs(
-  ctx: DiscoveryContext,
-  site: OverlaySite,
-  contributed: Map<string, DiscoveredAB>,
-  overlayDir: string
-): Promise<void> {
-  const loaded = await loadABs(ctx, overlayDir, (source, path) => {
-    if (!contributed.delete(source)) {
-      unknownContribution(ctx, path, "disableAB", source, site.ns);
-    }
-  });
-  for (const experiment of loaded) {
-    contributed.set(experiment.source ?? experiment.name, experiment);
-  }
-}
-
 export async function overlayArtifacts(
   ctx: DiscoveryContext,
   overlayDir: string,