@cursor/july 0.1.108 → 0.1.111

package/src/storage.ts

@@ -4,19 +4,18 @@
  * Author `agent/storage.ts` with {@link defineStorage} to mirror the
  * framework's durable state into storage you own (a database, S3, a data
  * pipeline, …). Without it, state lives under `--state-root` on local disk
- * only, and eval/A/B history stays in process memory.
+ * only, and eval history stays in process memory.
  *
  * The sink is a plain key-value store — put/get/delete/list, no schema —
  * plus a conditional-write group ({@link StorageConfig.cas}; optional).
  * Implementing that small KV core is enough for
- * FULL functionality: eval-run and A/B history are derived over the core
- * when the optional dedicated tables ({@link StorageConfig.evals} and
- * {@link StorageConfig.abs}) are not authored — those groups exist as
- * backend-native optimizations (a real table, an analytics pipeline),
- * not as required-or-lose-history hooks:
+ * FULL functionality: eval-run history is derived over the core when the
+ * optional dedicated table ({@link StorageConfig.evals}) is not authored —
+ * that group exists as a backend-native optimization (a real table, an
+ * analytics pipeline), not as a required-or-lose-history hook:
  *
  * ```ts
- * import { defineStorage } from "@cursor/july/storage";
+ * import { defineStorage } from "@cursor/july/internal/storage";
  *
  * export default defineStorage({
  *   put: (key, value) => db.upsert(key, value),
@@ -25,7 +24,6 @@
  *   list: (prefix) => db.listByPrefix(prefix), // [{ key, value }] in key order
  *   cas: { getWithVersion: ..., putIfAbsent: ..., putIfVersion: ..., listKeys: ... },
  *   evals: { put: ..., delete: ..., list: ... }, // eval-runs table
- *   abs: { putSample: ... },                     // A/B table
  * });
  * ```
  *
@@ -51,9 +49,7 @@
  * interface is the durable mirror.
  */
 
-import type { ABMetricSample } from "./ab.js";
 import type { EvalRunSnapshot } from "./evals.js";
-import type { ABSnapshot } from "./internal/ab-snapshot.js";
 import { brandDefinition } from "./internal/brand.js";
 import { storageKeys } from "./storage-protocol.js";
 import type { JsonValue, KvCasResult, KvVersionedEntry } from "./types.js";
@@ -161,24 +157,6 @@ export interface StorageEvalsTable {
   list(ctx: StorageContext): EvalRunSnapshot[] | Promise<EvalRunSnapshot[]>;
 }
 
-/**
- * Dedicated table for live A/B metrics: one row per cumulative metric
- * sample (unique per `experiment` + `sessionId` + `at` — one boundary
- * event emits a sample per enrolled experiment), plus — optionally — the latest
- * aggregate snapshot so a replacement host with no local sessions can
- * still serve the A/Bs surface.
- */
-export interface StorageABTable {
-  /** Append one cumulative metric sample (turn complete/fail). */
-  putSample(sample: ABMetricSample, ctx: StorageContext): void | Promise<void>;
-  /** Upsert the latest aggregate snapshot (framework-throttled). Optional. */
-  putSnapshot?(snapshot: ABSnapshot, ctx: StorageContext): void | Promise<void>;
-  /** Latest saved aggregate snapshot (replacement-host backfill). Optional. */
-  getSnapshot?(
-    ctx: StorageContext
-  ): ABSnapshot | undefined | null | Promise<ABSnapshot | undefined | null>;
-}
-
 /**
  * Conditional writes (CAS) — the coordination tier of the storage backend
  * contract. Plain storage works without it, so existing backends keep
@@ -186,9 +164,8 @@ export interface StorageABTable {
  * it, so implementing this group yourself only comes up for BYO storage.
  *
  * Grouped under {@link StorageConfig.cas} rather than as loose methods —
- * matching the `evals` / `abs` table groups — so `defineStorage`
- * validates the whole group at once: there is no meaningful
- * half-implementation.
+ * matching the `evals` table group — so `defineStorage` validates the
+ * whole group at once: there is no meaningful half-implementation.
  *
  * Version tokens are opaque per-key strings that change on every
  * successful write (counter, UUID, content hash — whatever is cheap for
@@ -234,14 +211,6 @@ export interface StorageConfig {
    * memory (lost on restart).
    */
   evals?: StorageEvalsTable;
-  /**
-   * Dedicated A/B table — a backend-native optimization, not a
-   * requirement. When omitted, `defineStorage` derives it over the KV
-   * core: `putSample` and `putSnapshot` need only core `put` (always
-   * present), `getSnapshot` additionally needs core `get`. Session event
-   * logs remain the assignment/fold source of truth either way.
-   */
-  abs?: StorageABTable;
   /**
    * Conditional writes (CAS). Optional for plain storage — existing
    * backends keep working without it. The built-in backends (`fileKv`,
@@ -256,11 +225,25 @@ export interface StorageConfig {
    * growing memory; it never stalls the agent loop.
    */
   put(key: string, value: JsonValue, ctx: StorageContext): void | Promise<void>;
+  /**
+   * Store several values in one call. Optional — the coordinator uses it
+   * only when present, so authored sinks keep `put`'s strict one-at-a-time
+   * ordering. Entries belong to one flush and are independent keys; the
+   * implementation may write them in a single backend round trip. Report
+   * per-entry outcomes, index-aligned with the input: one key's failure
+   * must not take down its batch siblings. A thrown rejection is treated
+   * as every entry failing (logged and dropped, at-most-once) — reserve it
+   * for faults that genuinely precede any write.
+   */
+  putMany?(
+    entries: Array<{ key: string; value: JsonValue }>,
+    ctx: StorageContext
+  ): Promise<Array<{ key: string; error?: unknown }>>;
   /** Remove a key. Optional — without it, deletions are skipped. */
   delete?(key: string, ctx: StorageContext): void | Promise<void>;
   /**
    * Point lookup. Optional — required for **lazy restore** (resolving a
-   * continuation token on a replacement host) and the A/B backfill.
+   * continuation token on a replacement host).
    * Return `undefined`/`null` only for a **definitive** miss: on the lazy
    * restore path a throw propagates and fails the follow-up (retryable) —
    * a store outage must not read as "unknown token", which would fork the
@@ -300,13 +283,14 @@ export type StorageDefinition = StorageConfig & {
 
 /**
  * Author the project storage sink (`agent/storage.ts`, default
- * export). See the module doc for semantics and an example.
+ * export). Import from `@cursor/july/internal/storage`, not
+ * `@cursor/july`. See the module doc for semantics and an example.
  */
 export function defineStorage(config: StorageConfig): StorageDefinition {
   if (typeof config.put !== "function") {
     throw new Error("defineStorage: config.put must be a function");
   }
-  for (const hook of ["get", "list", "delete"] as const) {
+  for (const hook of ["get", "list", "delete", "putMany"] as const) {
     const value = config[hook];
     if (value !== undefined && typeof value !== "function") {
       throw new Error(
@@ -334,46 +318,28 @@ export function defineStorage(config: StorageConfig): StorageDefinition {
     // A partial group is a bug, not a legacy config: half-implemented CAS
     // would pass the capability probe.
     const missingCasHooks = casHooks.filter(
-      (hook) => typeof cas[hook] !== "function"
+      hook => typeof cas[hook] !== "function"
     );
     if (missingCasHooks.length > 0) {
       throw new Error(
         `defineStorage: ${missingCasHooks
-          .map((hook) => `cas.${hook}`)
+          .map(hook => `cas.${hook}`)
           .join(
             ", "
           )} must be ${missingCasHooks.length === 1 ? "a function" : "functions"} when the cas group is set`
       );
     }
   }
-  if (config.abs !== undefined) {
-    if (typeof config.abs.putSample !== "function") {
-      throw new Error(
-        "defineStorage: abs.putSample must be a function when the abs table is set"
-      );
-    }
-    for (const hook of ["putSnapshot", "getSnapshot"] as const) {
-      const value = config.abs[hook];
-      if (value !== undefined && typeof value !== "function") {
-        throw new Error(
-          `defineStorage: abs.${hook} must be a function when set`
-        );
-      }
-    }
-  }
   // Validate eagerly so a bad policy fails at discovery, not first flush.
   resolveStoragePolicy(config.policy);
   // A backend that implements only the KV core gets full functionality:
-  // the dedicated tables are backend-native optimizations, derived over
-  // the core when absent. Authored groups always win.
+  // the dedicated table is a backend-native optimization, derived over
+  // the core when absent. An authored group always wins.
   const derivedEvals =
     config.evals === undefined ? deriveEvalsTable(config) : undefined;
-  const derivedAbs =
-    config.abs === undefined ? deriveAbsTable(config) : undefined;
   return brandDefinition("storage", {
     ...config,
     ...(derivedEvals === undefined ? {} : { evals: derivedEvals }),
-    ...(derivedAbs === undefined ? {} : { abs: derivedAbs }),
   });
 }
 
@@ -399,57 +365,15 @@ function deriveEvalsTable(
       ),
     delete: (runId, ctx) =>
       config.delete?.(storageKeys.evalRun(ctx.agentName, runId), ctx),
-    list: async (ctx) => {
+    list: async ctx => {
       const entries =
         (await config.list?.(storageKeys.evalRunsPrefix(ctx.agentName), ctx)) ??
         [];
-      return entries.map((entry) => entry.value as unknown as EvalRunSnapshot);
+      return entries.map(entry => entry.value as unknown as EvalRunSnapshot);
     },
   };
 }
 
-/**
- * A/B table over the KV core. Each sample lands as its own key (identity
- * = experiment + sessionId + at, matching the dedicated table's row
- * uniqueness): appending to one array value would need read-modify-write
- * — lost updates under concurrent writers without CAS, and unbounded
- * value growth — while a key per sample keeps `putSample` a blind put
- * with real append-only semantics. The aggregate snapshot lives at one
- * fixed key via plain `put` (last-write-wins is correct for "latest").
- * Requires only core `put`; `getSnapshot` is included when core `get`
- * exists.
- */
-function deriveAbsTable(config: StorageConfig): StorageABTable {
-  const get = config.get;
-  return {
-    putSample: (sample, ctx) =>
-      config.put(
-        storageKeys.abSample(
-          ctx.agentName,
-          sample.experiment,
-          sample.sessionId,
-          sample.at
-        ),
-        sample as unknown as JsonValue,
-        ctx
-      ),
-    putSnapshot: (snapshot, ctx) =>
-      config.put(
-        storageKeys.abSnapshot(ctx.agentName),
-        snapshot as unknown as JsonValue,
-        ctx
-      ),
-    ...(get === undefined
-      ? {}
-      : {
-          getSnapshot: async (ctx: StorageContext) => {
-            const value = await get(storageKeys.abSnapshot(ctx.agentName), ctx);
-            return (value ?? undefined) as ABSnapshot | undefined;
-          },
-        }),
-  };
-}
-
 // ============================================================================
 // Policy resolution
 // ============================================================================

package/src/types.ts

@@ -10,7 +10,6 @@
 
 import type { InteractionUpdate, SDKCustomTool, ToolName } from "@cursor/sdk";
 import type { z } from "zod";
-import type { ABConfigFile } from "./ab.js";
 import type { FileSystem } from "./filesystem.js";
 import type {
   ContinuationClaim,
@@ -55,7 +54,6 @@ export type DefinitionKind =
   | "reminder"
   | "hook"
   | "eval"
-  | "ab"
   | "storage"
   | "artifacts"
   | "otel"
@@ -157,7 +155,7 @@ export function toPublicCloudInfo(
     ...rest,
     ...(repos !== undefined
       ? {
-          repos: repos.map((repo) => ({
+          repos: repos.map(repo => ({
             ...repo,
             url: redactHttpUrlCredentials(repo.url),
             ...(repo.prUrl !== undefined
@@ -285,6 +283,19 @@ export interface AgentConfig {
    * you to select a specific architecture.
    */
   architecture?: AgentArchitecture;
+  /**
+   * Persistent hosting for `architecture: "v2"`.
+   *
+   * Default (`false`): each session boots a pod from the release snapshot;
+   * framework and author state are mirrored to Cursor stores because pod
+   * disks are disposable.
+   *
+   * `true`: one long-lived pod per deployment runs each deployed version as
+   * a container over one state directory on the pod's disk. Nothing is
+   * mirrored: that directory is the durable copy. A redeploy starts the new
+   * version beside the old one on the same state, then drains the old one.
+   */
+  persistent?: boolean;
 }
 
 /** Hosted architecture on {@link AgentConfig.architecture}. */
@@ -1143,8 +1154,10 @@ export interface ExtensionOptions<TConfig, TInput = TConfig> {
  * `agent/extensions/<ns>.ts` to mount the extension with a configuration;
  * the extension's own modules import it to read that configuration.
  */
-export interface Extension<TConfig = undefined, TInput = TConfig>
-  extends ExtensionDeclaration {
+export interface Extension<
+  TConfig = undefined,
+  TInput = TConfig,
+> extends ExtensionDeclaration {
   (
     ...args: undefined extends TInput ? [config?: TInput] : [config: TInput]
   ): ExtensionMount;
@@ -1202,8 +1215,8 @@ export type DisabledConnectionDefinition =
 /**
  * `export default disable()` / `disableSkill()` / `disableHook()` /
  * `disableChannel()` / `disableSchedule()` / `disableSubagent()` /
- * `disableInstructions()` / `disableAB()` / `disableArtifacts()` in a
- * directory mount removes that contribution from the matching overlay slot.
+ * `disableInstructions()` / `disableArtifacts()` in a directory mount
+ * removes that contribution from the matching overlay slot.
  */
 export type DisabledDefinition = BrandedDefinition<"disabled">;
 
@@ -1232,8 +1245,6 @@ export interface DiscoveredExtension {
   instructions: boolean;
   /** Workspace seed paths the mount contributed. */
   seedFiles: string[];
-  /** Composed A/B experiment names (`<ns>__<name>`). */
-  abs: string[];
   /** Composed artifact kind names (`<ns>__<kind>`). */
   artifactKinds: string[];
 }
@@ -1313,7 +1324,7 @@ export function normalizeCursorAccountServers(
   if (servers === undefined || servers === "*") {
     return undefined;
   }
-  const trimmed = servers.map((server) => server.trim());
+  const trimmed = servers.map(server => server.trim());
   if (trimmed.length === 1 && trimmed[0] === "*") {
     return undefined;
   }
@@ -1327,8 +1338,8 @@ export function cursorAccountServersHasMixedWildcard(
   if (servers === undefined || servers === "*") {
     return false;
   }
-  const trimmed = servers.map((server) => server.trim());
-  return trimmed.includes("*") && trimmed.some((server) => server !== "*");
+  const trimmed = servers.map(server => server.trim());
+  return trimmed.includes("*") && trimmed.some(server => server !== "*");
 }
 
 /**
@@ -1615,15 +1626,6 @@ export interface PendingAuth {
 
 export type SessionEventPayload =
   | { type: "session.started"; data: { channelId: string; dryRun?: boolean } }
-  | {
-      /**
-       * Sticky A/B enrollment for one experiment (`defineAB` under `agent/ab`).
-       * Appended at session creation (before the first turn). `variant` is a
-       * key of the experiment's `variants`, or `null` for sticky skip.
-       */
-      type: "ab.assigned";
-      data: { experiment: string; variant: string | null };
-    }
   | {
       /** Cursor SDK agent id is known (cloud: `bc-…`; local: session id). */
       type: "agent.bound";
@@ -1813,8 +1815,8 @@ export interface TurnUsage {
 
 /**
  * Dollar cost of one turn's token usage (one agent loop pass).
- * Recorded on `turn.completed` events so traces, the playground, A/B
- * metrics, and the CLI can aggregate spend. Computed by
+ * Recorded on `turn.completed` events so traces, the playground, and the
+ * CLI can aggregate spend. Computed by
  * `POST /v1/models/estimate-cost` — billed usage events when available
  * (credits, discounts, CTF), otherwise live catalog pricing.
  */
@@ -1841,8 +1843,7 @@ export type SessionMode = "chat" | "task";
 
 /**
  * Why the session exists. `"eval"` is regression traffic (`defineEval` /
- * `agent-sdk eval` / playground Evals) and is excluded from live A/B
- * enrollment. Default `"live"`.
+ * `agent-sdk eval` / playground Evals). Default `"live"`.
  */
 export type SessionPurpose = "live" | "eval";
 
@@ -1859,12 +1860,6 @@ export interface SessionInfo {
   asOf?: string;
   auth: AuthContext | null;
   title?: string;
-  /**
-   * Sticky A/B arms for this session (`defineAB`): experiment name → variant
-   * key, or `null` for sticky skip. Present after enrollment at session
-   * create (live traffic only). Tools/hooks/harness overlays read this.
-   */
-  abs?: Readonly<Record<string, string | null>>;
   /**
    * Channel-local continuation key when the session is addressable for
    * follow-ups / reminders. Null when the session is not re-keyable.
@@ -1885,20 +1880,14 @@ export interface SessionRecord {
   channelId: string;
   mode: SessionMode;
   /**
-   * `"eval"` for harness sessions — skipped by {@link defineAB} enrollment.
-   * Older records omit this (treated as `"live"`).
+   * `"eval"` for harness sessions. Older records omit this (treated as
+   * `"live"`).
    */
   purpose?: SessionPurpose;
   /** Frozen at create from {@link SendMessageOptions.dryRun}. */
   dryRun?: boolean;
   /** Frozen at create from {@link SendMessageOptions.asOf}. */
   asOf?: string;
-  /**
-   * Denormalized sticky A/B arms (mirrors durable `ab.assigned` events) so
-   * the agent loop / tools can read arms without re-folding the log. Source
-   * of truth for stickiness remains the event stream.
-   */
-  abs?: Record<string, string | null>;
   /** Channel-local continuation key; null when the session is not addressable. */
   continuationKey: string | null;
   /**
@@ -2083,8 +2072,8 @@ export interface SendMessageOptions {
   /** Session display title (applied when creating a new session). */
   title?: string;
   /**
-   * Session purpose at create time. `"eval"` skips sticky A/B enrollment
-   * (`defineAB`) so regression runs do not mix into live metrics.
+   * Session purpose at create time. `"eval"` marks regression traffic so
+   * hooks, `defineResult`, and telemetry can tell it from live sessions.
    */
   purpose?: SessionPurpose;
   /**
@@ -2304,6 +2293,13 @@ export interface ChannelHandlerArgs {
    * pass `sessionId` in `tag` input to attribute one).
    */
   artifacts: ArtifactsApi;
+  /** Hosted Slack admission uses this to paint a warm follow-up. */
+  hasContinuationSession?(continuationToken: string): Promise<boolean>;
+  isContinuationBusy?(continuationToken: string): Promise<boolean>;
+  getContinuationLastBotMessageTs?(
+    continuationToken: string
+  ): Promise<string | undefined>;
+  interruptContinuation?(continuationToken: string): Promise<boolean>;
 }
 
 export type ChannelRouteHandler = (
@@ -2535,9 +2531,9 @@ export interface ChannelStartArgs {
 }
 
 /**
- * Descriptive metadata a channel pack attaches for tooling. Read by
- * discovery / `projectInfo` and CLI helpers (e.g. `agent-sdk github
- * forward`) — it never affects routing or dispatch.
+ * Metadata a channel pack attaches for discovery, `projectInfo`, and CLI
+ * helpers (e.g. `agent-sdk github forward`). Most fields are descriptive;
+ * explicitly documented protocol fields may also be consumed by the host.
  */
 export interface ChannelMeta {
   /** Well-known pack kind, e.g. `"github"` or `"slack"`. */
@@ -2574,6 +2570,24 @@ export interface ChannelMeta {
    * `deploymentEventTypes`.
    */
   factoryEventTypes?: readonly string[];
+  /**
+   * For Slack packs: the Events API event types this channel dispatches on
+   * (`app_mention`, `message`), derived from `engagement`. Extracted into
+   * the deploy manifest as `eventTypes` so hosted v2 fanout subscribes to
+   * exactly these. Local Socket Mode ignores it (the socket delivers
+   * whatever the app manifest subscribed to).
+   */
+  slackEventTypes?: readonly string[];
+  /**
+   * Static agentic-reply protocol for hosted Slack ingress. Only literals
+   * belong here: the control plane persists this declaration at deploy time
+   * and may act before author code starts.
+   */
+  slackReply?: {
+    mode: "agentic";
+    ack: string;
+    placeholder?: string;
+  };
   /**
    * For Slack packs with the opt-in channel watch: the allowlisted channels
    * (ids or `#names`) this channel dispatches on without a mention. Surfaced
@@ -2640,10 +2654,33 @@ export interface HttpChannelConfig {
     message: string,
     info: { auth: AuthContext | null }
   ) => string | Promise<string>;
+  /**
+   * Bind host state after the control plane names this session's mailbox
+   * key and before `send()`.
+   */
+  onAdmit?: (info: HttpSessionAdmitInfo) => void | Promise<void>;
   /** Stream-event handlers for sessions created over HTTP. */
   events?: ChannelEventHandlers;
 }
 
+/** Subject of a hosted HTTP startSession, seen by {@link HttpChannelConfig.onAdmit}. */
+export type HttpSessionAdmitInfo = {
+  message: string;
+  sessionKey: string;
+  dryRun?: boolean;
+  asOf?: string;
+  host: HostContext;
+};
+
+/** Reject a hosted startSession subject from {@link HttpChannelConfig.onAdmit}. */
+export class HttpSessionAdmitError extends Error {
+  readonly status = 400 as const;
+  constructor(message: string) {
+    super(message);
+    this.name = "HttpSessionAdmitError";
+  }
+}
+
 export type HttpChannelDefinition = HttpChannelConfig &
   BrandedDefinition<"http-channel">;
 
@@ -2745,16 +2782,24 @@ export interface ResultContext {
   workspaceDir: string;
   /** Full assistant text for the turn. */
   text: string;
+  /**
+   * The commit did not apply; re-run this turn with `message` so the
+   * model can revise. After two repairs the turn fails like a throw.
+   */
+  reject(message: string): never;
 }
 
 /**
  * Input to `defineResult` (authored at `agent/result.ts`).
- * Parse `ctx.text` in `commit`. Throw to fail the turn.
+ * Parse `ctx.text` in `commit`. Throw to fail the turn. Call
+ * {@link ResultContext.reject} for a model-correctable miss so the
+ * same turn can revise before `turn.completed`.
  */
 export interface ResultConfig {
   /**
    * Host actuation after the model finishes, before `turn.completed`.
-   * Throw to fail the turn. A dry-run session skips this callback.
+   * Throw to fail the turn. `ctx.reject(message)` re-prompts the model
+   * in this turn (two repairs). A dry-run session skips this callback.
    */
   commit: (ctx: ResultContext) => void | Promise<void>;
 }
@@ -3226,15 +3271,6 @@ export interface DiscoveredHook {
   definition: HookDefinition;
 }
 
-/** Live A/B metrics experiment (`agent/ab.ts` or `agent/ab/<name>.ts`). */
-export interface DiscoveredAB {
-  name: string;
-  /** File stem the experiment was loaded from (`ab` or a path under `ab/`). */
-  source?: string;
-  /** Branded `defineAB({ ... })` config (see `@cursor/july/ab`). */
-  definition: BrandedDefinition<"ab">;
-}
-
 export interface SeedFile {
   /** Path inside the session workspace. */
   relativePath: string;
@@ -3283,6 +3319,7 @@ export interface ResolvedAgent {
    * continuation defaults onto channels that omitted a selector.
    */
   architecture?: AgentArchitecture;
+  persistent?: boolean;
   tools: DiscoveredTool[];
   skills: DiscoveredSkill[];
   /**
@@ -3308,17 +3345,13 @@ export interface AgentProject {
   agentDir: string;
   name: string;
   agent: ResolvedAgent;
-  /** Built-in HTTP channel config (authored override or default). */
+  /** Built-in HTTP session channel. */
   httpChannel: HttpChannelDefinition;
   channels: DiscoveredChannel[];
   schedules: DiscoveredSchedule[];
   /** Named reminder handlers from `agent/reminders/*` (optional / additive). */
   reminders?: DiscoveredReminder[];
   hooks: DiscoveredHook[];
-  /** Live A/B metric experiments (`defineAB`). */
-  abs: DiscoveredAB[];
-  /** Optional `agent/ab.config.ts` (`defineABConfig`). */
-  abConfig?: ABConfigFile;
   /** Optional `agent/storage.ts` (`defineStorage`). */
   storage?: StorageDefinition;
   /** Optional `agent/artifacts.ts` (`defineArtifacts`). */
@@ -3415,6 +3448,8 @@ export interface AgentProjectInfo {
     deploymentEventTypes?: readonly string[];
     /** Change Monitor checkpoint or Factory issue event types the channel dispatches on, when declared. */
     factoryEventTypes?: readonly string[];
+    /** Slack Events API event types the channel dispatches on, when declared. */
+    slackEventTypes?: readonly string[];
     /** Slack channels watched for posts (opt-in channel watch), when declared. */
     slackChannelPosts?: readonly string[];
   }>;
@@ -3422,14 +3457,6 @@ export interface AgentProjectInfo {
   /** Named reminder handlers (`agent/reminders/<name>.ts`) when present. */
   reminders?: Array<{ name: string }>;
   hooks: string[];
-  /** Live A/B experiment names (`defineAB` under `agent/ab`). */
-  abs: string[];
-  /** Playground fold / durable-sink meta from `agent/ab.config.ts`. */
-  abConfig?: {
-    maxPlaygroundSessions?: number;
-    durableSamples: boolean;
-    durableSnapshots: boolean;
-  };
   /** Project storage sink from `agent/storage.ts`, when authored. */
   storage?: { name?: string };
   otel?: { serviceName?: string; enabled: true };
@@ -3498,11 +3525,12 @@ export interface RunnerTurnRequest {
   /** Cloud options when {@link runtime} is `"cloud"`. */
   cloud?: AgentCloudOptions;
   /**
-   * Composed instructions ({@link ResolvedAgent.instructions}) for runtimes
-   * whose harness cannot read the workspace `AGENTS.md` — grokbot turns
-   * carry them into the hosted session so they reach the Sand system
-   * prompt. Local turns read the materialized workspace instead and leave
-   * this unset.
+   * Composed instructions ({@link ResolvedAgent.instructions} plus identity
+   * and tool catalog) delivered as the harness system prompt. Local turns
+   * pass them to the Cursor SDK as `systemPrompt`, replacing Cursor's
+   * built-in prompt; grokbot turns carry them into the hosted session so
+   * they reach the Sand system prompt. Cloud turns leave this unset and
+   * inline the same text into the first prompt instead.
    */
   instructions?: string;
   /**

package/templates/agentic-owners/agent/channels/github.ts

@@ -1,7 +1,4 @@
-import {
-  defaultGitHubAuth,
-  githubChannel,
-} from "@cursor/july/channels/github";
+import { defaultGitHubAuth, githubChannel } from "@cursor/july/channels/github";
 import config from "../lib/config.js";
 import { githubOwnersForge } from "../lib/github.js";
 import { AgenticOwnersConfigValidationError } from "../lib/owners/parse.js";
@@ -27,8 +24,8 @@ export default githubChannel({
   cursorAccount: config.repos.length > 0 ? { repos: config.repos } : undefined,
   // The model never writes to GitHub; record_review actuates host-side.
   deliverReplies: false,
-  onStart: (args) => {
-    log = (line) => args.logger(`[agentic-owners] ${line}`);
+  onStart: args => {
+    log = line => args.logger(`[agentic-owners] ${line}`);
   },
   onPullRequest: async (ctx, pr) => {
     // A base retarget re-resolves policy against the new base. The fresh

package/templates/agentic-owners/agent/lib/github.ts

@@ -90,10 +90,10 @@ export function githubOwnersForge(
         pull_number: ref.number,
       });
       const requestedUsers = (data.requested_reviewers ?? []).flatMap(
-        (reviewer) => ("login" in reviewer ? [reviewer.login] : [])
+        reviewer => ("login" in reviewer ? [reviewer.login] : [])
       );
       const requestedTeams = (data.requested_teams ?? []).map(
-        (team) => `${ref.owner}/${team.slug}`
+        team => `${ref.owner}/${team.slug}`
       );
       return {
         number: data.number,
@@ -114,7 +114,7 @@ export function githubOwnersForge(
         pull_number: ref.number,
         per_page: 100,
       });
-      return files.map((file) => ({
+      return files.map(file => ({
         filename: file.filename,
         status: file.status,
         previousFilename: file.previous_filename,
@@ -201,7 +201,7 @@ export function githubOwnersForge(
         pull_number: ref.number,
         per_page: 100,
       });
-      return reviews.map((review) => ({
+      return reviews.map(review => ({
         id: review.id,
         state: review.state,
         body: review.body ?? "",
@@ -214,7 +214,7 @@ export function githubOwnersForge(
         octokit.rest.issues.listComments,
         { ...repo, issue_number: ref.number, per_page: 100 }
       );
-      return comments.map((comment) => ({
+      return comments.map(comment => ({
         id: comment.id,
         body: comment.body ?? "",
       }));