@cursor/july 0.1.97 → 0.1.99

package/src/channels/slack/progress-delivery.ts

@@ -0,0 +1,133 @@
+/**
+ * Mid-turn thread progress when `chat.startStream` is unavailable.
+ * One editable message; `setThreadStatus` stays on the caller.
+ */
+
+import type { ChannelEventContext } from "../../types.js";
+import { deleteMessage, postMessage, updateMessage } from "./api.js";
+import type { SlackLog } from "./log.js";
+import type { SlackBotToken, SlackChannelState } from "./types.js";
+
+type SlackChannel = ChannelEventContext<SlackChannelState>;
+
+export interface ProgressDeliveryDeps {
+  botToken: SlackBotToken | undefined;
+  getLog: () => SlackLog;
+}
+
+function activeProgressTs(state: SlackChannelState): string | null {
+  const ts = state.progressTs;
+  return ts == null || ts === "" ? null : ts;
+}
+
+export interface ProgressDelivery {
+  upsert(args: { channel: SlackChannel; text: string }): Promise<void>;
+  replace(args: { channel: SlackChannel; text: string }): Promise<boolean>;
+  clear(args: { channel: SlackChannel }): Promise<void>;
+}
+
+export function createProgressDelivery(
+  deps: ProgressDeliveryDeps
+): ProgressDelivery {
+  const { botToken, getLog } = deps;
+
+  const clear: ProgressDelivery["clear"] = async (args) => {
+    const state = args.channel.state;
+    const ts = activeProgressTs(state);
+    state.progressTs = null;
+    if (ts === null || state.channelId === null) {
+      return;
+    }
+    const deleted = await deleteMessage({
+      botToken,
+      channel: state.channelId,
+      ts,
+    });
+    if (!deleted.ok) {
+      getLog().warn("progress delete failed", {
+        error: deleted.error,
+        channel: state.channelId,
+        progress_ts: ts,
+      });
+    }
+  };
+
+  return {
+    async upsert(args) {
+      const state = args.channel.state;
+      if (
+        state.channelId === null ||
+        state.threadTs === null ||
+        args.text === ""
+      ) {
+        return;
+      }
+      const existing = activeProgressTs(state);
+      if (existing !== null) {
+        const updated = await updateMessage({
+          botToken,
+          channel: state.channelId,
+          ts: existing,
+          text: args.text,
+        });
+        if (updated.ok) {
+          return;
+        }
+        getLog().warn("progress update failed; posting a new message", {
+          error: updated.error,
+          channel: state.channelId,
+          thread_ts: state.threadTs,
+          progress_ts: existing,
+        });
+        await clear({ channel: args.channel });
+      }
+      try {
+        const posted = await postMessage({
+          botToken,
+          channel: state.channelId,
+          threadTs: state.threadTs,
+          text: args.text,
+        });
+        state.progressTs = posted.ts;
+      } catch (error) {
+        getLog().warn(
+          `progress post failed: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+          {
+            channel: state.channelId,
+            thread_ts: state.threadTs,
+          }
+        );
+      }
+    },
+
+    async replace(args) {
+      const state = args.channel.state;
+      const ts = activeProgressTs(state);
+      if (ts === null || state.channelId === null || args.text === "") {
+        return false;
+      }
+      const updated = await updateMessage({
+        botToken,
+        channel: state.channelId,
+        ts,
+        text: args.text,
+      });
+      if (!updated.ok) {
+        getLog().warn("progress replace failed", {
+          error: updated.error,
+          channel: state.channelId,
+          progress_ts: ts,
+        });
+        return false;
+      }
+      state.lastPostedText = args.text;
+      state.lastBotMessageTs = ts;
+      state.progressTs = null;
+      return true;
+    },
+
+    clear,
+  };
+}

package/src/channels/slack/types.ts

@@ -61,8 +61,14 @@ export interface SlackChannelState {
   streamTs: string | null;
   /** Channel id used when the stream was started. */
   streamChannelId?: string | null;
-  /** Last cumulative text sent via appendStream (for incremental append). */
+  /** Last assistant text delivered to the thread (stream or postMessage). */
   lastPostedText?: string | null;
+  /**
+   * Text of the current assistant block already written into the open stream.
+   * The harness restarts its cumulative text at every tool boundary, so the
+   * append delta cannot be measured against {@link lastPostedText}.
+   */
+  streamBlockText?: string | null;
   /**
    * Slack message ts of the agent's last delivered reply in this thread.
    * Warm turns use this as the `<slack_thread_delta>` watermark.
@@ -73,6 +79,8 @@ export interface SlackChannelState {
    * for the rest of the turn.
    */
   streamingUnavailable?: boolean;
+  /** Editable progress message ts when `chat.startStream` is unavailable. */
+  progressTs: string | null;
   /**
    * Message ts of approval cards keyed by tool call id (for
    * replacing Approve/Deny buttons after a decision).

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

@@ -76,8 +76,9 @@ export const AGENT_SERVE_STORE_SOURCE_ID_ENV_VAR =
  * user-level store above. The user store carries author-facing bytes
  * (`ctx.host.files`, skills, memory, artifacts) and is browsable and
  * mountable; the framework store carries engine-owned session state —
- * session records, event transcripts, continuation index, and the SDK
- * conversation mirror — and is never exposed to authors or models.
+ * session records, event transcripts, hosted-execution run logs,
+ * continuation index, and the SDK conversation mirror — and is never
+ * exposed to authors or models.
  * Provisioned by the v2 deploy pipeline alongside the user store; v1
  * deployments have only the user store.
  */

package/src/index.ts

@@ -79,6 +79,10 @@ export {
   V2EngineError,
 } from "./continuation.js";
 export { defineHook } from "./hooks.js";
+export {
+  InvalidAsOfError,
+  VacuousTimeArgsError,
+} from "./internal/as-of.js";
 export type { LoadAgentProjectOptions } from "./internal/discovery.js";
 export {
   formatDiagnostics,

package/src/internal/as-of.ts

@@ -0,0 +1,107 @@
+const TIMEZONE_SUFFIX = /(?:Z|[+-]\d{2}:?\d{2})$/i;
+
+export class InvalidAsOfError extends Error {
+  constructor(value: string) {
+    super(
+      `asOf must be an ISO-8601 instant with a timezone (e.g. ` +
+        `2026-08-31T12:00:00Z); received ${JSON.stringify(value)}.`
+    );
+    this.name = "InvalidAsOfError";
+  }
+}
+
+function parseInstant(value: string): Date | undefined {
+  const trimmed = value.trim();
+  if (trimmed === "" || !TIMEZONE_SUFFIX.test(trimmed)) {
+    return undefined;
+  }
+  const instant = new Date(trimmed);
+  return Number.isNaN(instant.getTime()) ? undefined : instant;
+}
+
+export function normalizeAsOf(value: string | undefined): string | undefined {
+  if (value === undefined) {
+    return undefined;
+  }
+  const instant = parseInstant(value);
+  if (instant === undefined) {
+    throw new InvalidAsOfError(value);
+  }
+  return instant.toISOString();
+}
+
+export function sessionClock(asOf: string | undefined): () => Date {
+  if (asOf === undefined) {
+    return () => new Date();
+  }
+  const frozen = new Date(asOf).getTime();
+  return () => new Date(frozen);
+}
+
+export class VacuousTimeArgsError extends Error {
+  constructor(toolName: string, missing: readonly string[]) {
+    super(
+      `Tool "${toolName}" declares timeArgs ` +
+        `${JSON.stringify(missing)} that its input schema does not define, ` +
+        `so bounding would silently check nothing. Make the declaration ` +
+        `match the schema's property names.`
+    );
+    this.name = "VacuousTimeArgsError";
+  }
+}
+
+export function assertTimeArgs(
+  tools: readonly {
+    name: string;
+    definition: { timeArgs?: readonly string[] };
+    inputSchema?: { properties?: Record<string, unknown> };
+  }[],
+  asOf: string | undefined
+): void {
+  if (asOf === undefined) {
+    return;
+  }
+  for (const tool of tools) {
+    const declared = tool.definition.timeArgs;
+    if (declared === undefined || declared.length === 0) {
+      continue;
+    }
+    const properties = tool.inputSchema?.properties ?? {};
+    const missing = declared.filter((name) => !(name in properties));
+    if (missing.length > 0) {
+      throw new VacuousTimeArgsError(tool.name, missing);
+    }
+  }
+}
+
+export function timeArgViolation(
+  input: unknown,
+  timeArgs: readonly string[],
+  asOf: string
+): string | undefined {
+  const record =
+    typeof input === "object" && input !== null
+      ? (input as Record<string, unknown>)
+      : {};
+  const frozen = new Date(asOf).getTime();
+  for (const name of timeArgs) {
+    const value = record[name];
+    const instant = typeof value === "string" ? parseInstant(value) : undefined;
+    if (instant === undefined) {
+      return (
+        `Time argument "${name}" must be an absolute ISO-8601 instant with ` +
+        `a timezone (e.g. ${asOf}); received ${JSON.stringify(value)}. This ` +
+        `session reads the world as of ${asOf} — supply absolute bounds at ` +
+        `or before that instant and retry.`
+      );
+    }
+    if (instant.getTime() > frozen) {
+      return (
+        `Time argument "${name}" (${JSON.stringify(value)}) is later than ` +
+        `the instant this session reads the world as of (${asOf}). Supply ` +
+        `bounds at or before that instant and retry.`
+      );
+    }
+  }
+  return undefined;
+}

package/src/internal/cli-deploy.ts

@@ -66,6 +66,8 @@ import { stderrPalette } from "./terminal-style.js";
 
 const DEFAULT_POLL_INTERVAL_MS = 3_000;
 const DEFAULT_DEPLOY_TIMEOUT_MS = 10 * 60 * 1000;
+/** `--multi-tenant` HTTP deploy is Anysphere-only (team id 1). */
+const MULTI_TENANT_HTTP_DEPLOY_TEAM_ID = 1;
 
 /** One agent directory selected for deploy (single or multi-agent parent). */
 export type DeployTarget = ChildAgentDir;
@@ -114,7 +116,8 @@ export interface DeployCliOptions {
   allowDomains?: string[];
   /**
    * deploy `--multi-tenant`: add a release to an existing Cursor-managed
-   * (multi-tenant) product. Cannot create a new multi-tenant application.
+   * (multi-tenant) product. Hidden Anysphere-only flag. Cannot create a
+   * new multi-tenant application.
    */
   multiTenant?: boolean;
   /** Test seams. */
@@ -297,6 +300,14 @@ export async function cmdDeploy(options: DeployCliOptions): Promise<number> {
     return ctx;
   }
 
+  if (
+    options.multiTenant === true &&
+    ctx.teamId !== MULTI_TENANT_HTTP_DEPLOY_TEAM_ID
+  ) {
+    ctx.err("--multi-tenant is not available for this team.\n");
+    return 1;
+  }
+
   const targets = await resolveDeployTargets(options, ctx);
   if (typeof targets === "number") {
     return targets;
@@ -990,7 +1001,10 @@ async function deployOneAgentsdk(
       ...(args.multiTenant ? { multiTenant: true } : {}),
     });
   } catch (error) {
-    return renderApiError(error, ctx.err);
+    return renderApiError(error, ctx.err, {
+      multiTenant: args.multiTenant,
+      teamId: ctx.teamId,
+    });
   }
 
   if (ctx.noWait) {
@@ -1301,6 +1315,21 @@ export async function cmdDeploymentStatus(
   if (typeof ctx === "number") {
     return ctx;
   }
+  // Same dispatch as `stop`: v1 409s architecture-v2 slugs, so the v2
+  // GET goes first. A v2 404 (missing slug, or an older backend) falls
+  // through to the v1 agent-serve detail.
+  try {
+    const detail = await ctx.client.getAgentkitDeploy({
+      teamId: ctx.teamId,
+      slug,
+    });
+    renderAgentkitDeploymentStatus(ctx, detail);
+    return 0;
+  } catch (error) {
+    if (!(error instanceof DeployApiError) || error.status !== 404) {
+      return renderApiError(error, ctx.err);
+    }
+  }
   let detail: DeploymentDetail;
   try {
     detail = await ctx.client.getDeployment({ teamId: ctx.teamId, slug });
@@ -1393,6 +1422,40 @@ export async function cmdDeploymentStatus(
   return 0;
 }
 
+function renderAgentkitDeploymentStatus(
+  ctx: DeployCliContext,
+  detail: AgentkitDeployStatus
+): void {
+  if (ctx.json) {
+    ctx.out(`${JSON.stringify(detail, null, 2)}\n`);
+    return;
+  }
+  const lines = [
+    `${detail.slug} (team ${detail.teamId})`,
+    `  status:       ${detail.status}`,
+    `  architecture: v2`,
+    `  application:  ${detail.applicationId}`,
+    `  release:      ${detail.releaseId}`,
+    `  progress:     ${detail.progress}`,
+  ];
+  if (detail.statusMessage !== null && detail.statusMessage.trim() !== "") {
+    lines.push(`  step:         ${detail.statusMessage}`);
+  }
+  if (detail.repositories !== undefined) {
+    lines.push(
+      `  watching:     ${
+        detail.repositories.length === 0
+          ? "(nothing)"
+          : detail.repositories.join(", ")
+      }`
+    );
+  }
+  if (detail.lastError !== null && detail.lastError !== undefined) {
+    lines.push(`  last error:   ${sanitizeCustomerError(detail.lastError)}`);
+  }
+  ctx.out(`${lines.join("\n")}\n`);
+}
+
 // ============================================================================
 // stop <slug>
 // ============================================================================
@@ -1901,10 +1964,35 @@ async function pollUntil<
   };
 
   for (;;) {
-    const detail = await fetchDetail().catch((error: unknown) => {
+    let detail: T;
+    try {
+      detail = await fetchDetail();
+    } catch (error: unknown) {
+      // Capacity / rate-limit on GET is not a bake failure. The v2 accept
+      // already started freeze; keep polling until the wait budget expires.
+      if (
+        isTransientDeployStatusError(error) &&
+        Date.now() - startedAt < ctx.timeoutMs
+      ) {
+        if (!ctx.json) {
+          const elapsed = Math.round((Date.now() - startedAt) / 1000);
+          const label = "Waiting for status (server busy)";
+          if (tty) {
+            ctx.err(`\r\x1b[2K${slug}: ${label} (${elapsed}s)`);
+            sawProgress = true;
+          } else if (label !== lastLabel) {
+            ctx.err(`${slug}: ${label}\n`);
+          }
+          lastLabel = label;
+        }
+        const waitMs = transientDeployStatusWaitMs(error, ctx.pollIntervalMs);
+        const remaining = ctx.timeoutMs - (Date.now() - startedAt);
+        await sleep(Math.max(0, Math.min(waitMs, remaining)));
+        continue;
+      }
       finishProgressLine();
       throw error;
-    });
+    }
     report(detail);
     if (terminal.has(detail.status)) {
       finishProgressLine();
@@ -1922,6 +2010,28 @@ async function pollUntil<
   }
 }
 
+/** Load-shed / rate-limit on status GET — the deploy itself may still be baking. */
+function isTransientDeployStatusError(error: unknown): error is DeployApiError {
+  return (
+    error instanceof DeployApiError &&
+    (error.status === 503 || error.status === 429)
+  );
+}
+
+function transientDeployStatusWaitMs(
+  error: DeployApiError,
+  pollIntervalMs: number
+): number {
+  if (
+    error.status === 429 &&
+    error.retryAfterSeconds !== undefined &&
+    error.retryAfterSeconds > 0
+  ) {
+    return Math.max(pollIntervalMs, error.retryAfterSeconds * 1000);
+  }
+  return pollIntervalMs;
+}
+
 /**
  * Wait until GET 404s (the delete reconciler purged the record). Treats
  * other errors as failures. Throws DeployApiError on timeout.
@@ -2000,16 +2110,26 @@ function deployFailureDetail(lastError: string | null | undefined): string {
   return `: ${sanitizeCustomerError(lastError.trim())}`;
 }
 
-function renderApiError(error: unknown, err: (text: string) => void): number {
+function renderApiError(
+  error: unknown,
+  err: (text: string) => void,
+  context?: { multiTenant?: boolean; teamId?: number }
+): number {
   if (error instanceof DeployApiError) {
     err(`${error.message}\n`);
     if (
       error.status === 409 &&
       error.message.includes("application multiTenant does not match")
     ) {
-      err(
-        "This slug is a Cursor-managed (multi-tenant) product. Redeploy it with --multi-tenant.\n"
-      );
+      if (context?.multiTenant === true) {
+        err(
+          "This slug is a single-tenant application. Redeploy it without --multi-tenant.\n"
+        );
+      } else if (context?.teamId === MULTI_TENANT_HTTP_DEPLOY_TEAM_ID) {
+        err(
+          "This slug is a Cursor-managed (multi-tenant) product. Redeploy it with --multi-tenant.\n"
+        );
+      }
     }
     return 1;
   }

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

@@ -616,12 +616,11 @@ export class CursorEventRelay {
           events: [...subscription.events],
         })),
       }),
-      // Empty subscriptions drop this consumer's registration on clean stop
-      // instead of leaving it to lapse by TTL.
-      buildDeregistrationBody: (consumerId) => ({
-        consumerId,
-        subscriptions: [],
-      }),
+      // No deregistration on stop: the backend only records events for a
+      // repo that some consumer is subscribed to, so dropping the
+      // registration leaves a hole in the log until the next process
+      // registers, and the durable offset cannot replay what was never
+      // written. A consumer that does not come back lapses by TTL.
       applyRegistrationResponse: (json) => {
         const result = json as { repos?: SubscriptionStatus[] };
         const statuses = result.repos ?? [];

package/src/internal/framework-file-storage.ts

@@ -8,15 +8,16 @@
  *   is browsable from the dashboard and mountable on cloud-runtime VMs;
  * - the **framework-level** store (`AGENT_SERVE_FRAMEWORK_STORE_SOURCE_ID`)
  *   holds engine-owned session state — session records, event transcripts,
- *   the continuation index, and the SDK conversation mirror — and is never
- *   exposed to authors or models.
+ *   hosted-execution run logs, the continuation index, and the SDK
+ *   conversation mirror — and is never exposed to authors or models.
  *
  * This module puts framework session state on the framework store. The
  * {@link storageKeys} scheme was designed for exactly this: keys are a
  * stable versioned contract that sinks may route on, so
  * {@link composeFrameworkStorage} splits one {@link StorageConfig} by key
- * kind — `session` / `session-events` / `continuation` go to the framework
- * file store (file-shaped; the store accepts values up to 64 MiB per
+ * kind — `session` / `session-events` / `session-runs` / `continuation`
+ * go to the framework file store (file-shaped; the store accepts values
+ * up to 64 MiB per
  * object without chunking, versus the KV proxy's 1 MiB row cap), while
  * author `kv`, eval runs, A/B samples, and conditional writes stay on the
  * control-plane KV proxy (the dashboard reads them there, and CAS needs a
@@ -40,6 +41,7 @@ import { mapBounded } from "./bounded.js";
 const FRAMEWORK_FILE_KINDS: ReadonlySet<string> = new Set([
   "session",
   "session-events",
+  "session-runs",
   "continuation",
 ]);
 
@@ -165,8 +167,11 @@ function decodeDocument(key: string, bytes: Uint8Array): JsonValue {
  * Split one storage core by key kind: framework session state to `files`,
  * everything else to `kv`. Spread over the KV backend when building the
  * full definition so its `evals` / `abs` groups (and the cursor-hosted
- * marker) ride along untouched; wrap the KV `cas` group with
- * {@link frameworkGuardedCas} rather than spreading it as-is.
+ * marker) ride along untouched. A KV `cas` group must not be spread as-is:
+ * conditional writes run on a KV database row, so one over a `session/` or
+ * `continuation/` key would read and write a different store than the
+ * routed plain core — silent split-brain. Nothing in the package CASes
+ * those kinds today.
  */
 export function composeFrameworkStorage(input: {
   kv: FileSinkStorageCore;
@@ -187,42 +192,3 @@ export function composeFrameworkStorage(input: {
     listNewest: undefined,
   };
 }
-
-/**
- * The KV backend's conditional writes, refusing framework-file keys.
- *
- * CAS runs on the KV proxy (a database row version); the plain core routes
- * framework session state to the file store. A future coordination path
- * that CASes a `session/` or `continuation/` key would otherwise read and
- * write a different store than the plain path — silent split-brain. Fail
- * loudly instead; nothing in the package CASes those kinds today.
- */
-export function frameworkGuardedCas(
-  cas: NonNullable<StorageConfig["cas"]>
-): NonNullable<StorageConfig["cas"]> {
-  const refuse = (key: string): void => {
-    if (isFrameworkFileKey(key)) {
-      throw new Error(
-        `framework file storage: conditional writes are KV-only, but "${key}" routes to the framework file store`
-      );
-    }
-  };
-  return {
-    getWithVersion: (key, ctx) => {
-      refuse(key);
-      return cas.getWithVersion(key, ctx);
-    },
-    putIfAbsent: (key, value, ctx) => {
-      refuse(key);
-      return cas.putIfAbsent(key, value, ctx);
-    },
-    putIfVersion: (key, value, expectedVersion, ctx) => {
-      refuse(key);
-      return cas.putIfVersion(key, value, expectedVersion, ctx);
-    },
-    listKeys: (prefix, ctx) => {
-      refuse(prefix);
-      return cas.listKeys(prefix, ctx);
-    },
-  };
-}