@cursor/july 0.1.3 → 0.1.5

package/src/internal/cli-ax.ts

@@ -41,6 +41,7 @@ import {
   fetchSessionEvents,
   formatSessionsTable,
   listSessions,
+  resolvePreviousSessionId,
 } from "./sessions-client.js";
 import { createStreamProgress } from "./stream-progress.js";
 import {
@@ -118,6 +119,11 @@ export interface AxCliOptions {
    * (CLI flag `--print`.)
    */
   print?: boolean;
+  /**
+   * `chat --resume` / `resume` with no session id: reattach the most
+   * recently updated followable session from `/v1/sessions`.
+   */
+  resume?: boolean;
   /** Abort signal (tests / programmatic stop of `playground` proxy). */
   signal?: AbortSignal;
 }
@@ -310,26 +316,30 @@ export async function cmdInit(options: AxCliOptions): Promise<number> {
  * prints a trajectory instead of the interactive UI.
  */
 /**
- * `resume <sessionId>` — reattach the interactive chat REPL to an existing
- * session (looks up the continuation token via `/v1/sessions` when omitted).
- * Same flags as `chat` (`--prod`, `--message`, `--json`, …). `--session`
- * is accepted as a redundant alias for the positional id.
+ * `resume [sessionId]` — reattach the interactive chat REPL to an existing
+ * session. When the id is omitted, picks the most recently updated
+ * followable session from `/v1/sessions` (same as `chat --resume`).
+ * Looks up the continuation token via `/v1/sessions` when
+ * `--continuation-token` is omitted. Same flags as `chat` (`--prod`,
+ * `--message`, `--json`, …). `--session` is accepted as a redundant
+ * alias for the positional id.
  */
 export async function cmdResume(
   sessionId: string | undefined,
   options: AxCliOptions
 ): Promise<number> {
   const resolved = trimNonEmpty(sessionId) ?? trimNonEmpty(options.sessionId);
-  if (resolved === undefined) {
-    process.stderr.write(
-      `Usage: ${CLI_COMMAND_NAME} resume <sessionId> [--url | --prod] [--message <text>] [--json] [--text]\n` +
-        `                          [--continuation-token <t>] [--slug <slug>] [--team <id>]\n`
-    );
-    return 2;
+  if (resolved !== undefined) {
+    return cmdChat({
+      ...options,
+      sessionId: resolved,
+      resume: false,
+    });
   }
   return cmdChat({
     ...options,
-    sessionId: resolved,
+    sessionId: undefined,
+    resume: true,
   });
 }
 
@@ -352,6 +362,35 @@ export async function cmdChat(options: AxCliOptions): Promise<number> {
         : (options.url ?? "http://127.0.0.1:3000"),
   });
 
+  let sessionId = trimNonEmpty(options.sessionId);
+  // `--resume` without an id → most recently updated followable session.
+  // An explicit `--session` / positional id always wins.
+  if (options.resume === true && sessionId === undefined) {
+    try {
+      const previous = await resolvePreviousSessionId({
+        baseUrl: target.agentUrl,
+        auth: {
+          bearerToken: options.bearerToken,
+          headers: target.headers,
+        },
+        fetchImpl: options.fetchImpl,
+      });
+      if (previous === undefined) {
+        process.stderr.write(
+          "No previous followable session found. Start one with " +
+            `\`${CLI_COMMAND_NAME} chat\` or pass a session id.\n`
+        );
+        return 1;
+      }
+      sessionId = previous;
+    } catch (error) {
+      process.stderr.write(
+        `${error instanceof Error ? error.message : String(error)}\n`
+      );
+      return 1;
+    }
+  }
+
   if (options.json) {
     if (message === undefined) {
       process.stderr.write("chat --json requires --message\n");
@@ -359,13 +398,13 @@ export async function cmdChat(options: AxCliOptions): Promise<number> {
     }
     let continuationToken = options.continuationToken;
     if (
-      options.sessionId !== undefined &&
+      sessionId !== undefined &&
       (continuationToken === undefined || continuationToken === "")
     ) {
       try {
         continuationToken = await lookupSessionContinuation({
           baseUrl: target.agentUrl,
-          sessionId: options.sessionId,
+          sessionId,
           auth: {
             bearerToken: options.bearerToken,
             headers: target.headers,
@@ -381,7 +420,7 @@ export async function cmdChat(options: AxCliOptions): Promise<number> {
     const result = await runSession({
       baseUrl: target.agentUrl,
       messages: [message],
-      sessionId: options.sessionId,
+      sessionId,
       continuationToken,
       bearerToken: options.bearerToken,
       headers: target.headers,
@@ -409,7 +448,7 @@ export async function cmdChat(options: AxCliOptions): Promise<number> {
     await runChat({
       baseUrl: target.agentUrl,
       message,
-      sessionId: options.sessionId,
+      sessionId,
       continuationToken: options.continuationToken,
       bearerToken: options.bearerToken,
       headers: target.headers,
@@ -892,7 +931,7 @@ export async function cmdSessions(options: AxCliOptions): Promise<number> {
 /**
  * `session <id>` — view a full session (trajectory text by default).
  * `--json` → trajectory JSON; `--events` (`rawEvents`) → raw event list.
- * Interactive reattach: `resume <id>` (or `chat --session`).
+ * Interactive reattach: `resume [id]` / `chat --resume` (or `chat --session`).
  */
 export async function cmdSession(
   sessionId: string | undefined,

package/src/internal/cli-deploy.ts

@@ -674,7 +674,8 @@ async function deployOne(
       `  generation:  ${detail.generation}\n` +
       `  kind:        ${detail.deploymentKind}\n` +
       `  alias:       ${aliasUrl}\n` +
-      `  playground:  ${CLI} playground --prod --slug ${slug} --team ${ctx.teamId}\n`
+      `  playground:  ${aliasUrl}/playground (sign in with the alias token)\n` +
+      `               or: ${CLI} playground --prod --slug ${slug} --team ${ctx.teamId}\n`
   );
   return 0;
 }
@@ -795,6 +796,7 @@ export async function cmdDeploymentStatus(
     `  generation:  ${detail.generation}`,
     `  kind:        ${detail.deploymentKind}`,
     `  alias:       ${aliasUrl}`,
+    `  playground:  ${aliasUrl}/playground`,
   ];
   if (detail.gitRepoUrl !== null && detail.gitRepoUrl !== undefined) {
     lines.push(`  repo:        ${detail.gitRepoUrl} @ ${detail.gitRef ?? ""}`);
@@ -1285,7 +1287,8 @@ function aliasTokenBlock(aliasToken: string): string {
   return (
     `\n  Alias token (shown ONCE — save it now, it cannot be retrieved again):\n\n` +
     `    ${aliasToken}\n\n` +
-    `  Send it as the X-Agent-Alias-Token header on requests to the alias URL.\n` +
+    `  Send it as the X-Agent-Alias-Token header on requests to the alias URL,\n` +
+    `  or paste it into the hosted playground (<alias>/playground) sign-in gate.\n` +
     `  Lost tokens: \`${CLI} rotate-token <slug>\` mints a replacement.\n\n`
   );
 }

package/src/internal/cli-github.ts

@@ -196,7 +196,7 @@ async function cmdGithubForward(options: GithubCliOptions): Promise<number> {
       );
       return 1;
     }
-    process.stderr.write(`[agent-serve] inferred --repo ${repo}\n`);
+    process.stderr.write(`[agentkit] inferred --repo ${repo}\n`);
   }
 
   const secret = options.secret ?? process.env.GITHUB_WEBHOOK_SECRET;
@@ -219,30 +219,30 @@ async function cmdGithubForward(options: GithubCliOptions): Promise<number> {
   });
 
   process.stderr.write(
-    `[agent-serve] forwarding ${org !== undefined ? `org ${org}` : `repo ${repo}`} to ${targets.length} channel${targets.length === 1 ? "" : "s"}:\n`
+    `[agentkit] forwarding ${org !== undefined ? `org ${org}` : `repo ${repo}`} to ${targets.length} channel${targets.length === 1 ? "" : "s"}:\n`
   );
   for (const target of targets) {
     process.stderr.write(
-      `[agent-serve]   → ${targetLabel(target)}  ${target.url}  (${target.events.join(", ")})\n`
+      `[agentkit]   → ${targetLabel(target)}  ${target.url}  (${target.events.join(", ")})\n`
     );
   }
   if (fanout) {
     process.stderr.write(
-      `[agent-serve] fan-out proxy on ${forwardUrl} (union events: ${events.join(", ")})\n`
+      `[agentkit] fan-out proxy on ${forwardUrl} (union events: ${events.join(", ")})\n`
     );
   }
   if (secret === undefined || secret === "") {
     process.stderr.write(
-      "[agent-serve] no signing secret — deliveries are unsigned. A `serve --dev` github channel accepts them; set GITHUB_WEBHOOK_SECRET on both sides to verify signatures (required for a non-dev target).\n"
+      "[agentkit] no signing secret — deliveries are unsigned. A `serve --dev` github channel accepts them; set GITHUB_WEBHOOK_SECRET on both sides to verify signatures (required for a non-dev target).\n"
     );
   }
   const envToken = detectGitHubEnvTokenOverride();
   if (envToken !== undefined) {
     process.stderr.write(
-      `[agent-serve] warning: ${githubEnvTokenHint(envToken)}\n`
+      `[agentkit] warning: ${githubEnvTokenHint(envToken)}\n`
     );
   }
-  process.stderr.write(`[agent-serve] running: gh ${redact(args)}\n`);
+  process.stderr.write(`[agentkit] running: gh ${redact(args)}\n`);
 
   try {
     return await spawnGh(args);
@@ -318,7 +318,7 @@ async function cmdGithubReplay(options: GithubCliOptions): Promise<number> {
   );
   if (unsupported.length > 0) {
     process.stderr.write(
-      `[agent-serve] cannot synthesize (skipped): ${unsupported.join(", ")}\n`
+      `[agentkit] cannot synthesize (skipped): ${unsupported.join(", ")}\n`
     );
   }
   if (eventsToReplay.length === 0) {
@@ -364,9 +364,7 @@ async function cmdGithubReplay(options: GithubCliOptions): Promise<number> {
       check,
     });
     if ("error" in result) {
-      process.stderr.write(
-        `[agent-serve] skipping ${event}: ${result.error}\n`
-      );
+      process.stderr.write(`[agentkit] skipping ${event}: ${result.error}\n`);
       continue;
     }
     synthesized.push(result);
@@ -378,7 +376,7 @@ async function cmdGithubReplay(options: GithubCliOptions): Promise<number> {
 
   const secret = options.secret ?? process.env.GITHUB_WEBHOOK_SECRET;
   process.stderr.write(
-    `[agent-serve] replaying ${ref.label} (${synthesized
+    `[agentkit] replaying ${ref.label} (${synthesized
       .map((s) => s.eventName)
       .join(
         ", "
@@ -401,7 +399,7 @@ async function cmdGithubReplay(options: GithubCliOptions): Promise<number> {
 
     if (options.out !== undefined) {
       const file = await writeReplayFixture(options.out, event);
-      process.stderr.write(`[agent-serve] wrote ${file}\n`);
+      process.stderr.write(`[agentkit] wrote ${file}\n`);
     }
 
     const label = eventLabel(event);
@@ -436,7 +434,7 @@ async function cmdGithubReplay(options: GithubCliOptions): Promise<number> {
               `${delivery.label} ${delivery.status || "ERR"}${delivery.ok ? "" : " (rejected)"}`
           )
           .join(", ") || "(no matching channel)";
-      process.stderr.write(`[agent-serve]   ${label} → ${summary}\n`);
+      process.stderr.write(`[agentkit]   ${label} → ${summary}\n`);
     }
   }
 
@@ -747,7 +745,7 @@ async function ensureWebhookExtension(
     };
   }
   process.stderr.write(
-    `[agent-serve] installing ${GITHUB_WEBHOOK_EXTENSION}@${GITHUB_WEBHOOK_EXTENSION_PIN}…\n`
+    `[agentkit] installing ${GITHUB_WEBHOOK_EXTENSION}@${GITHUB_WEBHOOK_EXTENSION_PIN}…\n`
   );
   if (
     (await tryExec({

package/src/internal/cursor/account-mcp.ts

@@ -231,7 +231,7 @@ export class CursorAccountMcpBridge {
             )
             .join(", ");
           this.logger(
-            `[agent-serve] Cursor account MCP connection "${ref.name}": ${
+            `[agentkit] Cursor account MCP connection "${ref.name}": ${
               catalog.servers.length === 0
                 ? "no matching connectors on this account — connect servers in Cursor (dashboard → MCP) or fix the `servers` filter"
                 : summary
@@ -242,7 +242,7 @@ export class CursorAccountMcpBridge {
           );
           if (needsAuth.length > 0) {
             this.logger(
-              `[agent-serve] Cursor account MCP connection "${ref.name}": ${needsAuth
+              `[agentkit] Cursor account MCP connection "${ref.name}": ${needsAuth
                 .map((server) => server.serverIdentifier)
                 .join(
                   ", "
@@ -252,7 +252,7 @@ export class CursorAccountMcpBridge {
         })
         .catch((error: unknown) => {
           this.logger(
-            `[agent-serve] Cursor account MCP connection "${ref.name}" preflight failed: ${describeError(error)}`
+            `[agentkit] Cursor account MCP connection "${ref.name}" preflight failed: ${describeError(error)}`
           );
         });
     }

package/src/internal/cursor/backend-client.ts

@@ -445,7 +445,7 @@ export class CursorBackendClient {
       value: body.data.accessToken,
       expiresAtMs: jwtExpiryMs(body.data.accessToken),
     };
-    this.logger("[agent-serve] cursor account: minted a fresh access token");
+    this.logger("[agentkit] cursor account: minted a fresh access token");
     return body.data.accessToken;
   }
 }

package/src/internal/cursor/credentials.ts

@@ -73,18 +73,23 @@ const storedCredentialsSchema: z.ZodObject<
 export type StoredCredentials = z.infer<typeof storedCredentialsSchema>;
 
 /**
- * `~/.config/agent-serve/credentials.json` (0600), honoring
- * `XDG_CONFIG_HOME`. `AGENT_SERVE_CONFIG_DIR` pins the directory outright
- * (tests, containers).
+ * `~/.config/agent-serve/` (honoring `XDG_CONFIG_HOME`), the host-level
+ * config directory for credentials and the update-check cache.
+ * `AGENT_SERVE_CONFIG_DIR` pins the directory outright (tests, containers).
  */
-export function credentialsFilePath(): string {
-  const configDir =
+export function configDirPath(): string {
+  return (
     process.env.AGENT_SERVE_CONFIG_DIR ??
     join(
       process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"),
       "agent-serve"
-    );
-  return join(configDir, "credentials.json");
+    )
+  );
+}
+
+/** `<configDir>/credentials.json` (0600). */
+export function credentialsFilePath(): string {
+  return join(configDirPath(), "credentials.json");
 }
 
 export async function readStoredCredentials(): Promise<

package/src/internal/cursor/github-credentials.ts

@@ -148,14 +148,14 @@ export class CursorGithubCredentialProvider {
         this.scheduleRefresh();
       }
       this.logger(
-        `[agent-serve] GitHub auth: refreshed Cursor account credential for ${this.repos.length} repo(s)`
+        `[agentkit] GitHub auth: refreshed Cursor account credential for ${this.repos.length} repo(s)`
       );
       return result.token;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       if (this.cached !== undefined && this.now() < this.cached.expiresAtMs) {
         this.logger(
-          `[agent-serve] GitHub auth: Cursor account credential refresh failed; using the current lease: ${message}`
+          `[agentkit] GitHub auth: Cursor account credential refresh failed; using the current lease: ${message}`
         );
         this.cached.refreshAtMs = Math.min(
           this.cached.expiresAtMs,
@@ -207,7 +207,7 @@ export class CursorGithubCredentialProvider {
     this.refreshTimer = setTimeout(() => {
       void this.getToken().catch((error: unknown) => {
         this.logger(
-          `[agent-serve] GitHub auth: Cursor account credential refresh failed: ${
+          `[agentkit] GitHub auth: Cursor account credential refresh failed: ${
             error instanceof Error ? error.message : String(error)
           }`
         );

package/src/internal/cursor-event-relay.ts

@@ -68,7 +68,10 @@ export interface CursorEventRelayOptions {
   repos: readonly string[];
   events: readonly string[];
   stateDir: string;
-  /** Called for each matching event; failures are logged, not retried. */
+  /**
+   * Called for each matching event; failures retry a bounded number of
+   * times, then log and skip.
+   */
   dispatch: (event: CursorScmEvent) => Promise<void>;
   logger: (line: string) => void;
   /** Test seam. Defaults to global fetch. */
@@ -213,6 +216,12 @@ export class CursorEventRelay {
           events: [...this.options.events],
         })),
       }),
+      // Empty subscriptions drop this consumer's registration on clean stop
+      // instead of leaving it to lapse by TTL.
+      buildDeregistrationBody: (consumerId) => ({
+        consumerId,
+        subscriptions: [],
+      }),
       applyRegistrationResponse: (json) => {
         const result = json as { repos?: SubscriptionStatus[] };
         const statuses = result.repos ?? [];
@@ -263,7 +272,7 @@ export class CursorEventRelay {
       if (!this.loggedSkippedRepos.has(event.repo)) {
         this.loggedSkippedRepos.add(event.repo);
         this.options.logger(
-          `[agent-serve] cursor-events: skipping events for ${event.repo}: not in this host's subscription (another consumer of this API key likely subscribed it)`
+          `[agentkit] cursor-events: skipping events for ${event.repo}: not in this host's subscription (another consumer of this API key likely subscribed it)`
         );
       }
       return false;

package/src/internal/cursor-relay-core.ts

@@ -12,6 +12,8 @@ import { randomUUID } from "node:crypto";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 
+import { LOG_PREFIX } from "./distribution.js";
+
 const OFFSET_SNAPSHOT_VERSION = 1 as const;
 const DEFAULT_POLL_WAIT_MS = 25_000;
 const DEFAULT_POLL_LIMIT = 100;
@@ -21,6 +23,11 @@ const DEFAULT_IDLE_POLL_DELAY_MS = 250;
 const MIN_BACKOFF_MS = 1_000;
 const MAX_BACKOFF_MS = 30_000;
 const AUTH_FAILURE_BACKOFF_MS = 60_000;
+/** Attempts per event before the offset advances past it. */
+const DISPATCH_ATTEMPTS = 3;
+const DISPATCH_RETRY_DELAYS_MS = [250, 1_000];
+/** Budget for the best-effort deregistration PUT during stop(). */
+const DEREGISTER_TIMEOUT_MS = 1_500;
 
 interface OffsetSnapshot {
   version: typeof OFFSET_SNAPSHOT_VERSION;
@@ -98,7 +105,7 @@ interface PollResponse<TEvent> {
  * anchor/poll/dedupe/offset loop, and backoff — is shared.
  */
 export interface RelayAdapter<TEvent extends { offset: string }> {
-  /** Log fragment, e.g. `cursor-events` → `[agent-serve] cursor-events: …`. */
+  /** Log fragment, e.g. `cursor-events` → `[agentkit] cursor-events: …`. */
   readonly logPrefix: string;
   /** Subscription registration path, e.g. `/v0/scm-events/subscriptions`. */
   readonly subscribePath: string;
@@ -106,6 +113,14 @@ export interface RelayAdapter<TEvent extends { offset: string }> {
   readonly pollPath: string;
   /** The registration request body for this consumer id. */
   buildRegistrationBody(consumerId: string): unknown;
+  /**
+   * The empty-scope registration body used to deregister this consumer on a
+   * clean stop. When present, `stop()` best-effort PUTs it so the consumer's
+   * registration does not linger as a ghost until its server-side TTL (a
+   * ghost with this host's agent names makes name routing ambiguous for a
+   * redeployed sibling until it expires).
+   */
+  buildDeregistrationBody?(consumerId: string): unknown;
   /**
    * Apply the (ok) registration response: update the accepted-scope filter
    * and return the human-readable outcome lines to log. The core logs them
@@ -119,7 +134,10 @@ export interface RelayAdapter<TEvent extends { offset: string }> {
    * the offset but are not dispatched.
    */
   shouldDispatch(event: TEvent): boolean;
-  /** Handle one matching event. Failures are logged, not retried. */
+  /**
+   * Handle one matching event. Failures retry a bounded number of times
+   * ({@link DISPATCH_ATTEMPTS}), then log and skip.
+   */
   dispatch(event: TEvent): Promise<void>;
 }
 
@@ -145,6 +163,14 @@ export class CursorRelayCore<TEvent extends { offset: string }> {
   private consumerId = "";
   /** undefined until the first registration, so a clean first success logs. */
   private lastRegistrationLog: string | undefined;
+  /** Whether any registration succeeded (gates the stop-time deregister). */
+  private registeredOnce = false;
+  /**
+   * The in-flight heartbeat re-registration, if any. `stop()` awaits it
+   * before deregistering so a just-sent heartbeat cannot land after the
+   * deregistration PUT and resurrect the registration for a full TTL.
+   */
+  private heartbeatPromise: Promise<boolean> | undefined;
 
   constructor(private readonly options: CursorRelayCoreOptions<TEvent>) {
     this.offsetStore = new RelayOffsetStore(options.stateDir);
@@ -168,7 +194,7 @@ export class CursorRelayCore<TEvent extends { offset: string }> {
     const registered = await this.registerUntilSuccess();
     if (!registered) return;
     this.registerTimer = setInterval(() => {
-      void this.registerOnce();
+      this.heartbeatPromise = this.registerOnce();
     }, DEFAULT_REGISTER_INTERVAL_MS);
     this.registerTimer.unref?.();
     await this.consumeLoop();
@@ -227,11 +253,61 @@ export class CursorRelayCore<TEvent extends { offset: string }> {
         timer.unref?.();
       }),
     ]);
+    // A heartbeat re-registration may be in flight (its fetch was just
+    // aborted); let it settle so it cannot land after the deregistration.
+    await this.heartbeatPromise?.catch(() => {});
+    await this.deregister();
+  }
+
+  /**
+   * Best-effort empty-scope PUT on clean stop, so this consumer's
+   * registration is dropped immediately instead of lingering until its
+   * server-side TTL. A ghost registration keeps this host's agent names
+   * live and makes name routing ambiguous for a redeployed sibling with a
+   * fresh consumer id. Failures only log — the TTL still cleans up.
+   */
+  private async deregister(): Promise<void> {
+    const adapter = this.options.adapter;
+    if (
+      adapter.buildDeregistrationBody === undefined ||
+      !this.registeredOnce ||
+      this.consumerId === ""
+    ) {
+      return;
+    }
+    const url = `${this.options.baseUrl.replace(/\/+$/, "")}${adapter.subscribePath}`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), DEREGISTER_TIMEOUT_MS);
+    timer.unref?.();
+    try {
+      const response = await this.fetchImpl(url, {
+        method: "PUT",
+        headers: {
+          authorization: `Bearer ${this.options.apiKey}`,
+          "content-type": "application/json",
+        },
+        body: JSON.stringify(adapter.buildDeregistrationBody(this.consumerId)),
+        signal: controller.signal,
+      });
+      if (response.ok) {
+        this.log("deregistered on shutdown");
+      } else {
+        this.log(
+          `deregistration failed: ${response.status} (registration lapses by TTL)`
+        );
+      }
+    } catch (error) {
+      this.log(
+        `deregistration failed: ${describeRelayError(error)} (registration lapses by TTL)`
+      );
+    } finally {
+      clearTimeout(timer);
+    }
   }
 
   private log(line: string): void {
     this.options.logger(
-      `[agent-serve] ${this.options.adapter.logPrefix}: ${line}`
+      `${LOG_PREFIX} ${this.options.adapter.logPrefix}: ${line}`
     );
   }
 
@@ -289,6 +365,7 @@ export class CursorRelayCore<TEvent extends { offset: string }> {
       this.logRegistrationOutcome(
         this.options.adapter.applyRegistrationResponse(json)
       );
+      this.registeredOnce = true;
       return true;
     } catch (error) {
       if (this.isAbort(error)) return false;
@@ -371,13 +448,7 @@ export class CursorRelayCore<TEvent extends { offset: string }> {
           // on replay after a crash between dispatch and save).
           if (compareStreamOffsets(event.offset, offset) <= 0) continue;
           if (this.options.adapter.shouldDispatch(event)) {
-            try {
-              await this.options.adapter.dispatch(event);
-            } catch (error) {
-              this.log(
-                `dispatch failed at offset ${event.offset}: ${describeRelayError(error)}`
-              );
-            }
+            await this.dispatchWithRetry(event);
           }
           offset = event.offset;
         }
@@ -401,6 +472,43 @@ export class CursorRelayCore<TEvent extends { offset: string }> {
     }
   }
 
+  /**
+   * Dispatch one event with a small bounded retry before the offset advances
+   * past it. Transient local failures (e.g. a connection reset while POSTing
+   * to the channel) used to drop the event outright; a poison event still
+   * only costs {@link DISPATCH_ATTEMPTS} tries and is then skipped, keeping
+   * at-least-once semantics without a retry loop.
+   */
+  private async dispatchWithRetry(event: TEvent): Promise<void> {
+    for (let attempt = 1; attempt <= DISPATCH_ATTEMPTS; attempt++) {
+      if (attempt > 1 && !this.running) {
+        this.log(
+          `dispatch abandoned at offset ${event.offset}: relay stopping`
+        );
+        return;
+      }
+      try {
+        await this.options.adapter.dispatch(event);
+        return;
+      } catch (error) {
+        if (attempt === DISPATCH_ATTEMPTS) {
+          this.log(
+            `dispatch failed at offset ${event.offset} after ${attempt} attempts: ${describeRelayError(error)}`
+          );
+          return;
+        }
+        this.log(
+          `dispatch attempt ${attempt} failed at offset ${event.offset}: ${describeRelayError(error)}; retrying`
+        );
+        await this.sleep(
+          DISPATCH_RETRY_DELAYS_MS[
+            Math.min(attempt - 1, DISPATCH_RETRY_DELAYS_MS.length - 1)
+          ]
+        );
+      }
+    }
+  }
+
   /** Log the failure, sleep, and return the backoff for the NEXT failure. */
   private async backoffAfterHttpFailure(
     response: Response,

package/src/internal/cursor-slack-relay.ts

@@ -44,8 +44,8 @@ export interface CursorSlackRelayOptions {
   agents: readonly CursorSlackAgentRegistration[];
   stateDir: string;
   /**
-   * Called for each event addressed to this consumer's agents; failures are
-   * logged, not retried.
+   * Called for each event addressed to this consumer's agents; failures
+   * retry a bounded number of times, then log and skip.
    */
   dispatch: (envelope: CursorSlackRelayEvent) => Promise<void>;
   logger: (line: string) => void;
@@ -122,7 +122,7 @@ export function createCursorSlackApiCaller(args: {
       };
     } catch (error) {
       args.logger?.(
-        `[agent-serve] cursor-slack: ${method} proxy call failed: ${describeRelayError(error)}`
+        `[agentkit] cursor-slack: ${method} proxy call failed: ${describeRelayError(error)}`
       );
       return { ok: false, error: "cursor_backend_unreachable" };
     }
@@ -163,6 +163,10 @@ export class CursorSlackRelay {
           })),
         };
       },
+      // Empty agents drop this consumer's registration on clean stop, so a
+      // redeployed sibling's identical agent names never tie with this
+      // host's ghost until the server-side TTL lapses.
+      buildDeregistrationBody: (consumerId) => ({ consumerId, agents: [] }),
       applyRegistrationResponse: (json) => {
         const result = json as RegistrationResponse;
         const agentStatuses = result.agents ?? [];

package/src/internal/distribution.ts

@@ -25,6 +25,14 @@ export const LEGACY_PACKAGE_NAME = "@anysphere/agent-serve";
  */
 export const AGENTKIT_PACKAGE_NAME = "@cursor/agentkit";
 
+/**
+ * Bracketed product tag for stderr / ServeOptions.logger lines
+ * (`[agentkit] …`, `[agentkit/slack] …`).
+ */
+export const LOG_PRODUCT = "agentkit";
+export const LOG_PREFIX: string = `[${LOG_PRODUCT}]`;
+export const SLACK_LOG_PREFIX: string = `[${LOG_PRODUCT}/slack]`;
+
 /**
  * Command name this CLI was invoked as. Both bins point at the same entry;
  * keep help text and hints copy-pasteable for whichever the user typed.