@cursor/july 0.1.108 → 0.1.109

package/src/storage-backends/file-kv.ts

@@ -1,19 +1,17 @@
 /**
- * File-backed `defineStorage` helper: a file-per-key KV store plus
- * file-backed `evals` / `abs` tables.
+ * File-backed `defineStorage` helper: a file-per-key KV store plus a
+ * file-backed `evals` table.
  *
  * Implements the whole `defineStorage` surface with zero external
  * dependencies: the four KV methods against a flat directory of JSON files
  * (one file per key, filename = URI-encoded key), the `cas`
  * group (single-process conditional writes — see the `cas` member below),
- * eval runs as
- * `eval-runs/<agent>/<runId>.json`, and A/B metrics as
- * `ab/<agent>/samples.ndjson` (append-only) plus `ab/<agent>/snapshot.json`
- * (latest aggregate). KV keys carry the agent name inside the framework
- * key scheme, but the evals/abs tables have no such scheme — the agent
- * subdirectory keeps agents sharing one storage `dir` from mixing or
- * overwriting each other's history. Swap this for a real backend
- * (Postgres, S3, …) in production; the contracts are identical.
+ * and eval runs as `eval-runs/<agent>/<runId>.json`. KV keys carry the
+ * agent name inside the framework key scheme, but the evals table has no
+ * such scheme — the agent subdirectory keeps agents sharing one storage
+ * `dir` from mixing or overwriting each other's history. Swap this for a
+ * real backend (Postgres, S3, …) in production; the contracts are
+ * identical.
  *
  * Layout notes:
  * - KV filenames encode the full key (`encodeURIComponent(key) + ".json"`),
@@ -29,7 +27,6 @@
 
 import { createHash, randomUUID } from "node:crypto";
 import {
-  appendFile,
   mkdir,
   readdir,
   readFile,
@@ -38,10 +35,8 @@ import {
   writeFile,
 } from "node:fs/promises";
 import { isAbsolute, join } from "node:path";
-import type { ABSnapshot } from "../ab.js";
 import type { EvalRunSnapshot } from "../evals.js";
 import type {
-  StorageABTable,
   StorageCasTable,
   StorageConfig,
   StorageContext,
@@ -63,7 +58,6 @@ type FileKvMethods = Required<
 > & {
   cas: StorageCasTable;
   evals: StorageEvalsTable;
-  abs: StorageABTable;
 };
 
 /** File-backed `defineStorage` methods, ready to spread into `defineStorage({...})`. */
@@ -72,12 +66,10 @@ export function fileKv(options?: FileKvOptions): FileKvMethods {
     const dir = options?.dir ?? ".agent-serve/kv";
     return isAbsolute(dir) ? dir : join(ctx.projectRoot, dir);
   };
-  // The evals/abs tables are scoped per agent (KV keys already carry the
-  // agent name via the framework key scheme).
+  // The evals table is scoped per agent (KV keys already carry the agent
+  // name via the framework key scheme).
   const evalRunsDir = (ctx: StorageContext): string =>
     join(resolveDir(ctx), "eval-runs", encodeURIComponent(ctx.agentName));
-  const abDir = (ctx: StorageContext): string =>
-    join(resolveDir(ctx), "ab", encodeURIComponent(ctx.agentName));
   const filePath = (ctx: StorageContext, key: string): string =>
     join(resolveDir(ctx), `${encodeURIComponent(key)}.json`);
   const readRaw = async (
@@ -270,39 +262,6 @@ export function fileKv(options?: FileKvOptions): FileKvMethods {
         return runs;
       },
     },
-
-    // A/B metrics: append-only sample log + latest aggregate snapshot,
-    // both under ab/<agent>/.
-    abs: {
-      async putSample(sample, ctx): Promise<void> {
-        const dir = abDir(ctx);
-        await mkdir(dir, { recursive: true });
-        await appendFile(
-          join(dir, "samples.ndjson"),
-          `${JSON.stringify(sample)}\n`,
-          "utf8"
-        );
-      },
-      async putSnapshot(snapshot, ctx): Promise<void> {
-        await writeJsonAtomic({
-          dir: abDir(ctx),
-          fileName: "snapshot.json",
-          value: snapshot,
-        });
-      },
-      async getSnapshot(ctx): Promise<ABSnapshot | undefined> {
-        try {
-          return JSON.parse(
-            await readFile(join(abDir(ctx), "snapshot.json"), "utf8")
-          ) as ABSnapshot;
-        } catch (error) {
-          if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-            return undefined;
-          }
-          throw error;
-        }
-      },
-    },
   };
 }
 

package/src/storage-protocol.ts

@@ -39,10 +39,9 @@ const DURABLE_SESSION_RECORD_KEY_RE =
  * | `{root}/{agent}/continuation/{channelId}/{token}` | `{ sessionId }` |
  * | `{root}/{agent}/kv/{key}` | Author JSON via `HostContext.kv` |
  *
- * The `eval-runs` / `ab-samples` / `ab-snapshot` families are minted only
- * by the tables `defineStorage` derives over the KV core; a backend that
- * authors dedicated `StorageConfig.evals` / `StorageConfig.abs` groups never
- * sees them.
+ * The `eval-runs` family is minted only by the table `defineStorage`
+ * derives over the KV core; a backend that authors a dedicated
+ * `StorageConfig.evals` group never sees it.
  */
 function createStorageKeys(root: string) {
   return {
@@ -94,19 +93,6 @@ function createStorageKeys(root: string) {
     evalRun: (agent: string, runId: string): string =>
       `${root}/${agent}/eval-runs/${keySegment(runId)}`,
     evalRunsPrefix: (agent: string): string => `${root}/${agent}/eval-runs/`,
-    /**
-     * One A/B metric sample (derived `abs` table); the segments mirror the
-     * dedicated table's row identity (experiment + sessionId + at).
-     */
-    abSample: (
-      agent: string,
-      experiment: string,
-      sessionId: string,
-      at: string
-    ): string =>
-      `${root}/${agent}/ab-samples/${keySegment(experiment)}/${keySegment(sessionId)}/${keySegment(at)}`,
-    /** Latest aggregate A/B snapshot (derived `abs` table, LWW). */
-    abSnapshot: (agent: string): string => `${root}/${agent}/ab-snapshot`,
   } as const;
 }
 

package/src/storage.ts

@@ -4,16 +4,15 @@
  * 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";
@@ -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`,
@@ -260,7 +229,7 @@ export interface StorageConfig {
   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
@@ -346,34 +315,16 @@ export function defineStorage(config: StorageConfig): StorageDefinition {
       );
     }
   }
-  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 }),
   });
 }
 
@@ -408,48 +359,6 @@ function deriveEvalsTable(
   };
 }
 
-/**
- * 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"
@@ -1202,8 +1200,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 +1230,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[];
 }
@@ -1615,15 +1611,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 +1800,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 +1828,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 +1845,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 +1865,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 +2057,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;
   /**
@@ -2574,6 +2548,14 @@ 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[];
   /**
    * For Slack packs with the opt-in channel watch: the allowlisted channels
    * (ids or `#names`) this channel dispatches on without a mention. Surfaced
@@ -3226,15 +3208,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;
@@ -3315,10 +3288,6 @@ export interface AgentProject {
   /** 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 +3384,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 +3393,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 };

package/templates/demo/README.md

@@ -7,19 +7,22 @@ walkthrough and comments the result.
 npx @cursor/july init ./my-demo --template demo
 ```
 
+`init` asks which repos to watch. Skip the prompt with
+`--var repos=owner/repo`.
+
 ## Run
 
+Connect GitHub in Cursor for those repos. Then sign the host in:
+
 ```bash
 agent-sdk login
 agent-sdk dev
 ```
 
-In the playground, run `/queue/pr` with a PR URL or `owner/repo#N`.
-Turns are sandboxed with `read` and `grep` only.
-
-GitHub: label `demo` or comment `/demo` on a host that terminates
-webhooks (`GITHUB_WEBHOOK_SECRET`). The host needs `GITHUB_TOKEN` or
-`gh auth` to read the PR and comment.
+In the playground, run `/queue/pr` with a PR URL or `owner/repo#N` from
+a watched repo. On GitHub, label a PR `demo` or comment `/demo`. Events
+and API calls use your Cursor GitHub connection. Turns are sandboxed
+with `read` and `grep` only.
 
 ```text
 POST /<slug>/v1/channels/queue/pr
@@ -29,5 +32,6 @@ POST /<slug>/v1/channels/queue/pr
 
 ## Files to edit
 
+- `agent/lib/repos.ts`: watched repos
 - `agent/instructions.md`: how to record
 - `evals/demo.eval.ts`: smoke case

package/templates/demo/agent/channels/github.ts

@@ -6,6 +6,7 @@ import {
   parseGitHubPrRef,
 } from "@cursor/july/channels/github";
 import { startDemo } from "../lib/collect.js";
+import { REPOS } from "../lib/repos.js";
 
 let send: SendMessageFn | undefined;
 
@@ -21,6 +22,7 @@ function wake(url: string, github: GitHubHandle) {
 export default githubChannel({
   botName: "demo-agent",
   webhookEvents: ["pull_request", "issue_comment"],
+  cursorAccount: { repos: REPOS },
   deliverReplies: false,
   onStart: async (args: ChannelStartArgs) => {
     send = args.send;

package/templates/demo/agent/channels/queue.ts

@@ -2,6 +2,7 @@ import { defineChannel, POST } from "@cursor/july/channels";
 import { parseGitHubPrRef } from "@cursor/july/channels/github";
 import { z } from "zod";
 import { startDemo } from "../lib/collect.js";
+import { REPOS, watches } from "../lib/repos.js";
 
 export default defineChannel({
   routes: [
@@ -12,9 +13,12 @@ export default defineChannel({
       }),
       handler: async (_req, { send, host, body }) => {
         const ref = parseGitHubPrRef(body.pr);
-        if (ref === undefined) {
+        if (ref === undefined || !watches(`${ref.owner}/${ref.repo}`)) {
           return Response.json(
-            { ok: false, error: "need a PR URL or owner/repo#N" },
+            {
+              ok: false,
+              error: `need a PR URL or owner/repo#N in ${REPOS.join(", ")}`,
+            },
             { status: 400 }
           );
         }

package/templates/demo/agent/lib/repos.ts

@@ -0,0 +1,5 @@
+export const REPOS: readonly string[] = ["owner/repo"];
+
+export function watches(fullName: string): boolean {
+  return REPOS.some((repo) => repo.toLowerCase() === fullName.toLowerCase());
+}

package/templates/demo/init.json

@@ -0,0 +1,25 @@
+{
+  "questions": [
+    {
+      "id": "repos",
+      "prompt": "Which GitHub repos should this agent record walkthroughs for?",
+      "hint": "Comma-separated owner/repo. One GitHub owner.",
+      "placeholder": "acme/api, acme/web",
+      "parse": "owner-repo-list"
+    }
+  ],
+  "replace": [
+    {
+      "file": "agent/lib/repos.ts",
+      "find": "[\"owner/repo\"]",
+      "answer": "repos",
+      "as": "json-array"
+    },
+    {
+      "file": "README.md",
+      "find": "owner/repo",
+      "answer": "repos",
+      "as": "first"
+    }
+  ]
+}