@cursor/july 0.1.95 → 0.1.96

package/src/internal/managed-delivery.ts

@@ -0,0 +1,125 @@
+/**
+ * Envelope-carried installation config for managed-product deliveries
+ * (plan 0002 Stack H1; envelope shape from Stack B1).
+ *
+ * On the v2 architecture a managed product (security-reviewer, …) is many
+ * single-tenant deployments: the pre-signal trigger gate matches the
+ * customer's automation trigger before a workflow starts and stamps the
+ * matched automation uuid + an opaque installation-config reference on the
+ * attributed session envelope. The delivery activity forwards the matched
+ * installation-config document to the fork **inside the webhook payload it
+ * POSTs to the channel**, under {@link MANAGED_DELIVERY_PAYLOAD_KEY} — the
+ * same embed-in-payload pattern the legacy deployment event stream used
+ * for its source marker.
+ *
+ * This module is the one contract both sides share: the control-plane
+ * delivery path embeds with {@link withManagedDeliveryConfig}; the agent's
+ * channels detect and read with {@link parseManagedDeliveryConfig}. The
+ * document mirrors the sync layer's `ManagedAutomationConfigDoc` **policy**
+ * fields that "ride the delivery envelope to the fork" (posting mode,
+ * managed config, trigger snapshots for the channel's staleness guard);
+ * readers ignore unknown fields so a newer sync can add material without
+ * breaking older forks. The automation's MCP server refs deliberately do
+ * NOT ride here: they travel on the hosted-admission envelope's
+ * `managedAutomation` slice (plan 0002 G2, `hosted-delivery-protocol.ts` /
+ * `hosted-managed-automation.ts`) so one mechanism owns MCP attach.
+ *
+ * INTERNAL: first-party host plumbing shared by agents in `factory/*`,
+ * consumed via relative source imports. Deliberately excluded from the
+ * published `@cursor/july` npm package (see the `files` whitelist).
+ */
+
+/**
+ * Key inside the delivered webhook payload under which the delivery
+ * activity embeds the matched installation config. Chosen to never
+ * collide with a provider webhook field (GitHub and Origin payloads have
+ * no `cursor*` keys).
+ */
+export const MANAGED_DELIVERY_PAYLOAD_KEY = "cursorManagedDelivery" as const;
+
+/**
+ * The matched installation-config document as it rides the delivery to
+ * the fork. Required: the matched automation uuid (B1 attribution).
+ * Everything else is optional; absent fields keep the channel's default
+ * posture (post, all modules enabled, no staleness guard).
+ */
+export interface ManagedDeliveryInstallationConfig {
+  /** Source managed automation uuid the pre-signal gate matched. */
+  matchedAutomationUuid: string;
+  /** Opaque `<installationId>@<resourceVersion>` config reference. */
+  installationConfigRef?: string;
+  managedType?: string;
+  name?: string;
+  /**
+   * Whether product output (PR comments, …) posts for this installation,
+   * or the run stays check/shadow-only. Channels post only on `"post"`
+   * (or when the field is absent) — any other value fails closed to
+   * shadow, so a newer mode name never posts by accident.
+   */
+  postingMode?: string;
+  managedConfig?: Record<string, unknown>;
+  /**
+   * The automation's git triggers as `GitTrigger.toJson()` snapshots.
+   * The channel re-checks the delivery against them (staleness guard:
+   * the config may have changed between admission and delivery).
+   */
+  triggerSnapshots?: unknown[];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function nonEmptyString(value: unknown): string | undefined {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  return trimmed === "" ? undefined : trimmed;
+}
+
+/**
+ * Read the embedded installation config out of a delivered webhook
+ * payload. Returns undefined for payloads without the key (legacy
+ * deliveries, host relay, fixtures) and for documents missing the
+ * required matched automation uuid — the channel then runs its legacy
+ * path unchanged. Malformed optional fields are dropped, not fatal.
+ */
+export function parseManagedDeliveryConfig(
+  payload: unknown
+): ManagedDeliveryInstallationConfig | undefined {
+  if (!isRecord(payload)) {
+    return undefined;
+  }
+  const doc = payload[MANAGED_DELIVERY_PAYLOAD_KEY];
+  if (!isRecord(doc)) {
+    return undefined;
+  }
+  const matchedAutomationUuid = nonEmptyString(doc.matchedAutomationUuid);
+  if (matchedAutomationUuid === undefined) {
+    return undefined;
+  }
+  return {
+    matchedAutomationUuid,
+    installationConfigRef: nonEmptyString(doc.installationConfigRef),
+    managedType: nonEmptyString(doc.managedType),
+    name: nonEmptyString(doc.name),
+    postingMode: nonEmptyString(doc.postingMode),
+    managedConfig: isRecord(doc.managedConfig) ? doc.managedConfig : undefined,
+    triggerSnapshots: Array.isArray(doc.triggerSnapshots)
+      ? doc.triggerSnapshots
+      : undefined,
+  };
+}
+
+/**
+ * Embed one matched installation config into the webhook payload the
+ * delivery activity POSTs to the channel. Pure; used by the control-plane
+ * delivery path and by channel tests building fixture envelopes.
+ */
+export function withManagedDeliveryConfig(
+  payload: Record<string, unknown>,
+  config: ManagedDeliveryInstallationConfig
+): Record<string, unknown> {
+  return { ...payload, [MANAGED_DELIVERY_PAYLOAD_KEY]: config };
+}

package/src/internal/runtime-dispatch-runner.ts

@@ -13,6 +13,7 @@ import type {
   AgentRunner,
   PrewarmOutcome,
   RunnerPrewarmRequest,
+  SteerAckOutcome,
 } from "./sdk-runner.js";
 
 export interface RuntimeDispatchingRunnerOptions {
@@ -45,6 +46,15 @@ export class RuntimeDispatchingRunner implements AgentRunner {
     return this.options.sdkRunner.runTurn(request);
   }
 
+  async steer(request: {
+    sessionId: string;
+    text: string;
+  }): Promise<SteerAckOutcome> {
+    return (
+      (await this.options.sdkRunner.steer?.(request)) ?? "revert_to_followup"
+    );
+  }
+
   async prewarm(request: RunnerPrewarmRequest): Promise<PrewarmOutcome> {
     // Prewarming is a local-harness concern; the engine only calls it for
     // local-runtime agents.

package/src/internal/sdk-runner.ts

@@ -16,6 +16,7 @@ import {
   createAgentPlatform,
   type LocalAgentStore,
   type ModelSelection,
+  type Run,
   type RunResult,
   type SDKAgent,
 } from "@cursor/sdk";
@@ -31,10 +32,18 @@ import {
 import { mapSdkTokenUsage, usageTokenSum } from "./cloud-turn-cost.js";
 import type { ConversationMirror } from "./conversation-mirror.js";
 import { resolveApiKeySync } from "./cursor/credentials.js";
+import { describeError } from "./describe-error.js";
+
+/** Mirrors @cursor/sdk's SteerAckOutcome; the published dist may predate it. */
+export type SteerAckOutcome = "complete_delivered" | "revert_to_followup";
 
 /** Internal seam between the session engine and the Cursor SDK harness. */
 export interface AgentRunner {
   runTurn(request: RunnerTurnRequest): Promise<TurnOutcome>;
+  steer?(request: {
+    sessionId: string;
+    text: string;
+  }): Promise<SteerAckOutcome>;
   /**
    * Resolve a local workspace before any session needs it, so the first turn
    * is not the one that pays for it. Best effort, hence the reported outcome:
@@ -193,6 +202,7 @@ function retryReason(
 
 export class CursorSdkRunner implements AgentRunner {
   private readonly agents = new Map<string, CachedAgentHandle>();
+  private readonly activeRuns = new Map<string, Run>();
   private readonly stores = new Map<string, Promise<LocalAgentStore>>();
   private readonly prewarmReleases: Array<() => Promise<void>> = [];
 
@@ -322,15 +332,9 @@ export class CursorSdkRunner implements AgentRunner {
       ) {
         await request.onRequestId(run.requestId);
       }
+      this.activeRuns.set(request.sessionId, run);
       try {
         const result = await run.wait();
-        // Mirror the conversation before replying: on hosted v2 the pod can
-        // be parked as soon as the execution reply lands, so a
-        // fire-and-forget write would race VM teardown. Failed turns still
-        // checkpoint the user message, so they persist too.
-        if (request.runtime === "local") {
-          await this.persistConversation(request, agent.agentId);
-        }
         let outcome = toTurnOutcome(result);
         if (outcome.status === "error") {
           // An error result usually means the handle's transport is poisoned
@@ -353,7 +357,25 @@ export class CursorSdkRunner implements AgentRunner {
         }
         return outcome;
       } finally {
+        if (this.activeRuns.get(request.sessionId) === run) {
+          this.activeRuns.delete(request.sessionId);
+        }
         signal?.removeEventListener("abort", onAbort);
+        // Mirror the conversation before replying: on hosted v2 the pod can
+        // be parked as soon as the execution reply lands, so a
+        // fire-and-forget write would race VM teardown. In the `finally` so
+        // a `wait()` that THROWS (transport death mid-turn, an abort with
+        // no follow-up) still persists the checkpoints the turn already
+        // wrote — the store is local SQLite, safe to read on the throw
+        // path, and persistConversation swallows its own errors. Guarded
+        // here (not just inside the helper) so unmirrored turns keep their
+        // exact post-wait sequencing.
+        if (
+          request.runtime === "local" &&
+          this.options.conversationMirror !== undefined
+        ) {
+          await this.persistConversation(request, agent.agentId);
+        }
       }
     } catch (error) {
       // Drop the cached agent so a dead Connect/HTTP2 session cannot poison
@@ -363,6 +385,28 @@ export class CursorSdkRunner implements AgentRunner {
     }
   }
 
+  async steer(request: {
+    sessionId: string;
+    text: string;
+  }): Promise<SteerAckOutcome> {
+    const run = this.activeRuns.get(request.sessionId) as
+      | (Run & {
+          steer?: (text: string) => Promise<SteerAckOutcome>;
+        })
+      | undefined;
+    if (run?.steer === undefined) {
+      return "revert_to_followup";
+    }
+    try {
+      return await run.steer(request.text);
+    } catch (error) {
+      this.log(
+        `[agent-sdk] session ${request.sessionId}: steer failed: ${describeError(error)}`
+      );
+      return "revert_to_followup";
+    }
+  }
+
   /**
    * Build the local executor for a workspace before any session asks for it.
    * The warmed executor is reference counted, so the lease is held until
@@ -484,7 +528,11 @@ export class CursorSdkRunner implements AgentRunner {
   private async buildLocalOptions(
     request: RunnerPrewarmRequest
   ): Promise<AgentOptions> {
-    const store = await this.resolveStore(request);
+    // Not resolveStore: an injected store is used synchronously (no
+    // microtask, no thenable assimilation), exactly as before the mirror
+    // existed.
+    const store =
+      this.options.store ?? (await this.getStore(request.runnerStateDir));
     return {
       ...this.buildSharedOptions(request),
       // The built-in tool allowlist rides AgentOptions, not `local`, and is

package/src/internal/server.ts

@@ -1286,6 +1286,8 @@ function mountAgentRoutes(
           channelId,
           hostedSessionId,
         }),
+      drainSessionDurability: (sessionId) =>
+        engine.drainSessionDurability(sessionId),
     });
   }
   // Playground lists/opens Slack (and other channel) sessions across

package/src/internal/session-engine.ts

@@ -136,10 +136,11 @@ import {
   SCHEDULE_CHANNEL_PREFIX,
 } from "./prompt-context.js";
 import { assertCloudCanHonorAccountServersFilters } from "./resolved-connections.js";
-import type { AgentRunner } from "./sdk-runner.js";
+import type { AgentRunner, SteerAckOutcome } from "./sdk-runner.js";
 import { sessionExternalLinks } from "./session-links.js";
 import { SessionStore } from "./session-store.js";
 import { syncSkillsToStore } from "./skills-sync.js";
+import { steeringEnabled } from "./steering.js";
 import { StorageCoordinator } from "./storage-coordinator.js";
 import type { FrameworkSessionStore } from "./storage-roles.js";
 import { decideToolCall, resolveEffect } from "./tool-policy.js";
@@ -698,6 +699,9 @@ export class SessionEngine {
     ) {
       return;
     }
+    if (steeringEnabled()) {
+      return;
+    }
     try {
       await materializeSlackNudgeCarrier({
         harnessCwd,
@@ -1359,18 +1363,52 @@ export class SessionEngine {
     });
   }
 
+  private async steerIntoRunningTurn(
+    sessionId: string,
+    message: string
+  ): Promise<SteerAckOutcome> {
+    if (this.runner.steer === undefined) {
+      return "revert_to_followup";
+    }
+    try {
+      return await this.runner.steer({ sessionId, text: message });
+    } catch (error) {
+      this.logger(
+        `[session] steer failed for ${sessionId}: ${describeError(error)}`
+      );
+      return "revert_to_followup";
+    }
+  }
+
   private async admitTurn(
     sessionId: string,
     message: string,
     options: AdmitTurnOptions = {}
   ): Promise<boolean> {
     const admission = options.admission ?? "preempt";
+    if (
+      admission === "coalesce" &&
+      steeringEnabled() &&
+      this.isTurnRunning(sessionId)
+    ) {
+      const toolCtx = this.activeToolContexts.get(sessionId);
+      const steerOutcome = await this.steerIntoRunningTurn(sessionId, message);
+      if (steerOutcome === "complete_delivered") {
+        this.logger(`[session] steered into running turn ${sessionId}`);
+        if (toolCtx !== undefined) {
+          toolCtx.emit({ type: "message.received", data: { text: message } });
+          toolCtx.emit({ type: "nudge.delivered", data: {} });
+        }
+        return true;
+      }
+    }
+    // Re-checked after the steer: a turn that ended during it falls through
+    // and this message starts the next turn itself. Enqueueing here instead
+    // would orphan it — the completion drain already ran.
     if (admission === "coalesce" && this.isTurnRunning(sessionId)) {
       this.enqueueCoalesced(sessionId, {
         message,
-        ...(options.sourceTs === undefined
-          ? {}
-          : { sourceTs: options.sourceTs }),
+        sourceTs: options.sourceTs,
       });
       this.logger(`[session] coalesce enqueue ${sessionId}`);
       return true;
@@ -3394,6 +3432,28 @@ export class SessionEngine {
   // Session handles
   // ==========================================================================
 
+  /**
+   * Wait until everything this session has already emitted is durably
+   * mirrored: its dispatch chain first (the chain's tail runs the turn-end
+   * storage flush, so the record carries the boundary event's handler
+   * mutations), then the storage delivery queue. Hosted v2 awaits this
+   * before the execution reply — the pod can be parked the moment the
+   * reply lands, and an unflushed session record would strand a
+   * conversation whose blobs persisted but whose record (which selects the
+   * conversation to hydrate) never reached the sink. No-op without a
+   * storage mirror.
+   */
+  async drainSessionDurability(sessionId: string): Promise<void> {
+    if (this.storage === undefined) {
+      return;
+    }
+    const chain = this.dispatchChains.get(sessionId);
+    if (chain !== undefined) {
+      await chain.catch(() => {});
+    }
+    await this.storage.whenIdle();
+  }
+
   async waitForCompletion(sessionId: string): Promise<TurnOutcome> {
     // Drain admission first so pendingTurns → activeTurns is visible before we
     // decide the session is idle (reminders use this for queueBehindTurn).

package/src/internal/steering.ts

@@ -0,0 +1,17 @@
+/**
+ * Deploy-time switch between the two mid-turn follow-up carriers.
+ *
+ * With ENABLE_STEERING set ("1"/"true"), a Slack follow-up arriving mid-turn
+ * is steered into the running turn via Run.steer and the nudge-carrier file
+ * store is left uninstalled. Unset (the default), the pre-steering behavior
+ * is fully preserved: the carrier is materialized and follow-ups ride the
+ * nudge store to the running turn's next tool boundary.
+ *
+ * Read per call rather than cached so tests can flip it, and because this is
+ * a rollout switch: once steering has proven out in production the flag and
+ * the carrier both go away.
+ */
+export function steeringEnabled(): boolean {
+  const value = process.env.ENABLE_STEERING?.trim().toLowerCase();
+  return value === "1" || value === "true";
+}

package/src/storage-backends/cursor-hosted.ts

@@ -74,13 +74,16 @@ export interface CursorHostedStorageOptions {
    * `https://api.cursor.com`).
    */
   baseUrl?: string;
+  /** Bearer credential (default: `CURSOR_API_KEY`). */
+  apiKey?: string;
   /**
-   * Bearer credential (default: `CURSOR_API_KEY`). A function is
-   * re-resolved on every call: hosted freeze snapshots listen unsigned and
-   * bind the key file after serve start, so a value captured at construct
-   * time would be permanently absent.
+   * Lazy credential, re-resolved on every call and preferred over
+   * {@link apiKey}: hosted freeze snapshots listen unsigned and bind the
+   * key file after serve start, so a value captured at construct time
+   * would be permanently absent. Used by the platform-selected v2
+   * defaults; kept separate so `apiKey` stays a plain string for authors.
    */
-  apiKey?: string | (() => string | undefined);
+  resolveApiKey?: () => string | undefined;
   /** Injected for tests. */
   fetch?: typeof fetch;
 }
@@ -185,8 +188,7 @@ function toCasResult(response: KvCasResponse): KvCasResult {
 }
 
 function resolveApiKey(options: CursorHostedStorageOptions): string {
-  const configured =
-    typeof options.apiKey === "function" ? options.apiKey() : options.apiKey;
+  const configured = options.resolveApiKey?.() ?? options.apiKey;
   const key = (configured ?? process.env.CURSOR_API_KEY)?.trim();
   if (key === undefined || key === "") {
     throw new Error(

package/src/types.ts

@@ -1262,7 +1262,8 @@ export type ConnectionConfig = (
    * Local runtime only, like all server tools: a `runtime: "cloud"` agent
    * fails discovery, and hybrid per-send cloud sessions refuse the turn.
    * The listing runs once per turn; point this at endpoints that can
-   * answer `tools/list` cheaply.
+   * answer `tools/list` cheaply. Tools whose MCP `annotations.title` is
+   * `do-not-call` are omitted (vendor host-UI / MCP Apps helpers).
    */
   advertiseTools?: boolean;
   /**

package/templates/code-wiki/README.md

@@ -0,0 +1,34 @@
+# Code wiki
+
+Keeps `wiki/` pages current after a pull request merges. Opens a
+follow-up PR against that merge's base when a durable fact changed.
+Skips chores. Same-base updates stack on `wiki/<base>`.
+
+```bash
+npx @cursor/july init ./code-wiki --template code-wiki
+```
+
+`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
+```
+
+Events and API calls use your Cursor GitHub connection. Replay a merged PR:
+
+```bash
+agent-sdk github replay https://github.com/owner/repo/pull/1 --dir . --action closed
+```
+
+## Files
+
+- `agent/lib/repos.ts`: watched repos
+- `agent/lib/wiki.ts`: wiki path rules
+- `agent/instructions.md`: what counts as a wiki update
+- `evals/wiki.eval.ts`: skip and update smoke cases

package/templates/code-wiki/agent/agent.ts

@@ -0,0 +1,8 @@
+import { defineAgent } from "@cursor/july";
+
+export default defineAgent({
+  tools: ["read", "grep"],
+  local: {
+    sandbox: true,
+  },
+});

package/templates/code-wiki/agent/channels/github.ts

@@ -0,0 +1,144 @@
+import type { HostGitHubClient } from "@cursor/july";
+import {
+  defaultGitHubAuth,
+  githubChannel,
+} from "@cursor/july/channels/github";
+import { REPOS, watches } from "../lib/repos.js";
+import { WIKI_DIR, isWikiPath } from "../lib/wiki.js";
+
+const MAX_DIFF_CHARS = 150_000;
+const MAX_WIKI_PAGES = 40;
+const LIST_FILES_CAP = 3000;
+
+type Octokit = Awaited<ReturnType<HostGitHubClient["getOctokit"]>>;
+
+export default githubChannel({
+  cursorAccount: { repos: REPOS, permissions: "contents-write" },
+  deliverReplies: false,
+  onComment: () => null,
+  onPullRequest: async (ctx, pr) => {
+    if (!watches(ctx.repository.fullName)) {
+      return null;
+    }
+    if (pr.action !== "closed" || !pr.merged) {
+      return null;
+    }
+    if (pr.headRef.startsWith(`${WIKI_DIR}/`)) {
+      return null;
+    }
+    const octokit = await ctx.github.getOctokit();
+    const pull = {
+      owner: ctx.repository.owner,
+      repo: ctx.repository.name,
+      pull_number: pr.number,
+    };
+    const listed = await octokit.paginate(octokit.rest.pulls.listFiles, {
+      ...pull,
+      per_page: 100,
+    });
+    const files = listed.map((file) => file.filename);
+    if (
+      files.length > 0 &&
+      files.length < LIST_FILES_CAP &&
+      files.every(isWikiPath)
+    ) {
+      return null;
+    }
+    return {
+      auth: defaultGitHubAuth(ctx),
+      context: [
+        "This pull request merged. Read pr/files.txt, pr/diff.patch, and wiki/.",
+      ],
+      async workspaceFiles() {
+        const [diff, wiki] = await Promise.all([
+          octokit.rest.pulls.get({ ...pull, mediaType: { format: "diff" } }),
+          loadWiki(octokit, pull.owner, pull.repo, pr.baseRef),
+        ]);
+        const text = String(diff.data);
+        return {
+          "pr/base.ref": `${pr.baseRef}\n`,
+          "pr/files.txt": `${files.join("\n")}\n`,
+          "pr/diff.patch":
+            text.length > MAX_DIFF_CHARS
+              ? `${text.slice(0, MAX_DIFF_CHARS)}\n…[truncated]\n`
+              : text,
+          ...wiki,
+        };
+      },
+    };
+  },
+});
+
+async function loadWiki(
+  octokit: Octokit,
+  owner: string,
+  repo: string,
+  ref: string
+): Promise<Record<string, string>> {
+  const listed = await readContents(octokit, {
+    owner,
+    repo,
+    path: WIKI_DIR,
+    ref,
+  });
+  if (!Array.isArray(listed)) {
+    return { "wiki/pages.txt": "" };
+  }
+  const markdown = listed.filter(
+    (item) => item.type === "file" && item.name.endsWith(".md")
+  );
+  const truncated = markdown.length > MAX_WIKI_PAGES;
+  const files = markdown.slice(0, MAX_WIKI_PAGES);
+  const pages: Record<string, string> = {};
+  await Promise.all(
+    files.map(async (file) => {
+      const body = await readContents(octokit, {
+        owner,
+        repo,
+        path: `${WIKI_DIR}/${file.name}`,
+        ref,
+      });
+      if (
+        body === undefined ||
+        Array.isArray(body) ||
+        body.encoding !== "base64" ||
+        typeof body.content !== "string"
+      ) {
+        return;
+      }
+      pages[`${WIKI_DIR}/${file.name}`] = Buffer.from(
+        body.content,
+        "base64"
+      ).toString("utf8");
+    })
+  );
+  const names = Object.keys(pages).sort();
+  pages["wiki/pages.txt"] = truncated
+    ? `${names.join("\n")}\n…[truncated]\n`
+    : `${names.join("\n")}\n`;
+  return pages;
+}
+
+async function readContents(
+  octokit: Octokit,
+  args: { owner: string; repo: string; path: string; ref: string }
+) {
+  try {
+    const { data } = await octokit.rest.repos.getContent(args);
+    return data;
+  } catch (error) {
+    if (isNotFound(error)) {
+      return undefined;
+    }
+    throw error;
+  }
+}
+
+function isNotFound(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "status" in error &&
+    error.status === 404
+  );
+}

package/templates/code-wiki/agent/instructions.md

@@ -0,0 +1,39 @@
+# Code wiki
+
+You keep the in-repo wiki current after a pull request merges.
+
+## Read
+
+The workspace has `pr/files.txt`, `pr/diff.patch`, and `wiki/`.
+`wiki/pages.txt` lists existing pages. Missing pages mean the wiki is
+empty. Read the file list and the pages that own the change. Use the
+diff only to test a fact.
+
+## Decide
+
+Update only when the merge changes a durable fact someone would look
+up later: how a system works, a public or operator contract, a default
+or ownership change, a removed feature.
+
+An empty wiki is not a license to document the whole repo. Create a
+page only for a durable contract in this merge.
+
+Skip lint, format, lockfiles, dependency pins, tests-only, cherry-picks,
+backports, telemetry-only changes, one-off bug fixes that leave the
+described behavior the same, knobs the wiki never mentioned, and facts
+the matching page already states.
+
+Do not write a changelog or a PR list.
+
+## Write
+
+Call `apply_wiki` once.
+
+- Skip: `{ verdict: "skip", reason }` with one line.
+- Update: `{ verdict: "update", reason, pages }` with full page bodies.
+
+Pages stay under `wiki/`, flat, `*.md`. Keep `_index.md` in sync when
+you add a page. Each catalog line names the page and the paths it owns.
+Short declarative sentences. Edit only the stale or missing facts.
+
+Reply with `skip` or `update` and the reason.

package/templates/code-wiki/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());
+}