@cursor/july 0.1.97 → 0.1.99

package/docs/reference/cli.md

@@ -594,7 +594,7 @@ commands with an explicit `--json` flag skip this automatic check.
 agent-sdk deploy [--dir <path>] [--slug <slug> | --all] [--team <id>]
                 [--repo <https-url>] [--ref <git-ref>] [--path <agent-path>]
                 [--cursor-events-repo owner/name]...
-                [--allow-domain <domain>]... [--multi-tenant]
+                [--allow-domain <domain>]...
                 [--no-wait] [--json]
 ```
 
@@ -622,12 +622,6 @@ be a lowercase hostname with at least two labels and an alphabetic
 top-level domain. One leading `*.` wildcard is allowed. A deployment
 can declare at most 20 domains.
 
-`--multi-tenant` adds a release to an existing Cursor-managed
-(multi-tenant) product such as `security-reviewer`. It is valid only
-for `architecture: "v2"` and cannot create a new multi-tenant
-application — those stay on the operator seed path. Without the flag,
-HTTP deploy stays single-tenant and a managed slug 409s.
-
 By default, the command polls every three seconds for up to ten minutes
 and succeeds only when the deployment reaches `running`. `--no-wait`
 returns after the deployment request is accepted. Multi-agent deploys

package/docs/reference/http-api.md

@@ -53,6 +53,7 @@ and `playgroundUrl` deep-links the session in the playground.
 | `message` | Required user message |
 | `title` | Session title |
 | `dryRun` | Run read tools and stub write tools |
+| `asOf` | ISO-8601 instant with a timezone, frozen at create; the prompt states it, `ctx.now()` returns it, and tools declaring `timeArgs` refuse calls not bounded at or before it. `400` when unusable |
 | `workspaceFiles` | UTF-8 files written into the session workspace |
 | `cloud` | Per-session cloud options merged over the agent defaults |
 

package/docs/reference/tools.md

@@ -147,6 +147,31 @@ export default defineTool({
 `dryRunResult` keeps the result shape stable. Without it, a stubbed write
 returns `"Operation acknowledged."`. Traces mark the result as stubbed.
 
+### Bound time arguments under `asOf`
+
+Declare `timeArgs` with the input properties that carry time bounds. In a
+session created with `asOf`, every named argument must be an absolute
+ISO-8601 instant with a timezone, no later than the session's frozen
+instant. A call that omits one, or supplies a relative or later value, is
+refused with an error telling the model to retry with absolute bounds.
+Sessions without `asOf` ignore the declaration.
+
+```ts
+export default defineTool({
+  description: "Query telemetry between two instants.",
+  inputSchema: z.object({ since: z.string(), until: z.string() }),
+  effect: "read",
+  timeArgs: ["since", "until"],
+  async execute({ since, until }) {
+    return queryTelemetry(since, until);
+  },
+});
+```
+
+Every name in `timeArgs` must exist in the input schema; a session with
+`asOf` refuses to start otherwise, because a misspelled name would silently
+check nothing.
+
 ## Define an agent tool
 
 Set `execution: "agent"` and the tool materializes as a shell script

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cursor/july",
-  "version": "0.1.97",
+  "version": "0.1.99",
   "description": "(early alpha) Filesystem-first framework for defining Cursor agents as markdown and TypeScript and serving them over channels with the Cursor SDK.",
   "license": "SEE LICENSE IN LICENSE.md",
   "repository": {

package/src/bin/agent-serve.ts

@@ -71,6 +71,7 @@ import {
   isServeRestartWorker,
   runEnterRestartSupervisor,
 } from "../internal/serve-restart.js";
+import { flushSessionRunFatal } from "../internal/session-run-log.js";
 import { clearTerminal, stdoutPalette } from "../internal/terminal-style.js";
 import { cmdUpdate, warnIfOutdated } from "../internal/update-check.js";
 import type { AgentProject, AgentServeHandle } from "../types.js";
@@ -140,7 +141,7 @@ Usage:
   ${CLI} deploy      [--dir <path>] [--slug <slug> | --all] [--team <id>] [--json]
                           [--no-wait] [--repo <url>] [--ref <ref>]
                           [--path <agentPath>] [--cursor-events-repo <owner/name>]...
-                          [--allow-domain <domain>]... [--multi-tenant]
+                          [--allow-domain <domain>]...
   ${CLI} manifest    [--dir <path>] [--json]
   ${CLI} deployments [--team <id>] [--json]
   ${CLI} deployment  <slug> [--team <id>] [--json]
@@ -268,8 +269,6 @@ Commands:
               (flags always win). When --dir is a multi-agent parent,
               pick one interactively, or pass --slug / --all. First deploy
               of a slug prints the alias token exactly once — save it.
-              --multi-tenant adds a release to an existing Cursor-managed
-              product (v2 only); it cannot create a new multi-tenant app.
   deployments List the team's deployments (slug, status, generation, kind).
   deployment  Show one deployment in full (status, lastError, engine info).
   stop        Stop a deployment and wait until it reports stopped.
@@ -432,9 +431,6 @@ Options:
   --allow-domain     deploy: egress domain the engine pod may reach
                      (repeatable; unioned with hosting.egressDomains from the
                      agent manifest). Repo-backed deploys only.
-  --multi-tenant     deploy: add a release to an existing Cursor-managed
-                     (multi-tenant) product. architecture v2 only. Cannot
-                     create a new multi-tenant application.
   --from-argv        secrets set: allow NAME=VALUE on argv (leaks into shell
                      history and agent-captured terminals). Default is names
                      only with a hidden prompt or piped stdin.
@@ -578,6 +574,7 @@ async function main(argv: string[]): Promise<number> {
       all: { type: "boolean", default: false },
       "cursor-events-repo": { type: "string", multiple: true },
       "allow-domain": { type: "string", multiple: true },
+      // Hidden Anysphere-only flag; omitted from help.
       "multi-tenant": { type: "boolean", default: false },
       "from-argv": { type: "boolean", default: false },
       strict: { type: "boolean", default: false },
@@ -1729,7 +1726,9 @@ function installTransportErrorGuards(): void {
     process.stderr.write(
       `[agent-sdk] uncaughtException: ${error.stack ?? error.message}\n`
     );
-    process.exit(1);
+    void flushSessionRunFatal(error).finally(() => {
+      process.exit(1);
+    });
   });
 }
 

package/src/channels/github/github-channel.ts

@@ -13,6 +13,7 @@ import {
 } from "../../internal/continuation-identity.js";
 import { isDeferredChannelSession } from "../../internal/deferred-channel-session.js";
 import { isDevMode } from "../../internal/dev-mode.js";
+import { attachHostedAdmissionAdapter } from "../../internal/hosted-admission-adapter.js";
 import { bindLocalIngressSend } from "../../internal/local-ingress.js";
 import type {
   AgentCloudOptions,
@@ -804,6 +805,22 @@ export function githubChannel(
     ],
   });
   githubChannelOptionsByDefinition.set(definition, channelOptions);
+  attachHostedAdmissionAdapter(definition, {
+    kind: GITHUB_CHANNEL_KIND,
+    prepareArgs: withPropagatingGitHubBackgroundErrors,
+    dispatch: ({ eventType, payload, deliveryId, args }) =>
+      dispatchGitHubWebhook({
+        options: channelOptions,
+        eventName: eventType,
+        payload,
+        deliveryId,
+        args,
+      }),
+    getOutcome: (response) => {
+      const outcome = getGitHubDispatchOutcome(response);
+      return outcome === "skip" || outcome === "task" ? outcome : undefined;
+    },
+  });
   if (cursorCredentials !== undefined) {
     registerGithubCursorAccountRuntime(definition, {
       options,

package/src/channels/origin/origin-channel.ts

@@ -10,7 +10,9 @@ import {
   continuationSource,
   normalizeIdentity,
 } from "../../internal/continuation-identity.js";
+import { isDeferredChannelSession } from "../../internal/deferred-channel-session.js";
 import { isDevMode } from "../../internal/dev-mode.js";
+import { attachHostedAdmissionAdapter } from "../../internal/hosted-admission-adapter.js";
 import { bindLocalIngressSend } from "../../internal/local-ingress.js";
 import type {
   AgentCloudOptions,
@@ -441,11 +443,35 @@ function enrichEventContext(input: {
   };
 }
 
+export type OriginDispatchOutcome = "skip" | "send" | "task";
+
+const dispatchOutcomeByResponse = new WeakMap<
+  Response,
+  OriginDispatchOutcome
+>();
+
+function withDispatchOutcome(
+  response: Response,
+  outcome: OriginDispatchOutcome
+): Response {
+  dispatchOutcomeByResponse.set(response, outcome);
+  return response;
+}
+
+export function getOriginDispatchOutcome(
+  response: Response
+): OriginDispatchOutcome | undefined {
+  return dispatchOutcomeByResponse.get(response);
+}
+
 function skipped(
   reason: string,
   extra: Record<string, unknown> = {}
 ): Response {
-  return Response.json({ ok: true, skipped: true, reason, ...extra });
+  return withDispatchOutcome(
+    Response.json({ ok: true, skipped: true, reason, ...extra }),
+    "skip"
+  );
 }
 
 function acknowledgeTask(
@@ -462,9 +488,12 @@ function acknowledgeTask(
       });
     })
   );
-  return Response.json(
-    { ok: true, dispatched: true, mode: "task", ...extra },
-    { status: 202 }
+  return withDispatchOutcome(
+    Response.json(
+      { ok: true, dispatched: true, mode: "task", ...extra },
+      { status: 202 }
+    ),
+    "task"
   );
 }
 
@@ -485,12 +514,26 @@ async function startTurn(input: {
     title: input.dispatch.title ?? defaultOriginTitle(input.ctx),
     ...(input.cloud === undefined ? {} : { cloud: input.cloud }),
   });
-  return Response.json({
-    ok: true,
-    sessionId: session.id,
-    isNew: session.isNew,
-    continuationToken: session.continuationToken,
-  });
+  if (isDeferredChannelSession(session)) {
+    // Hosted admission captured the send; the control plane allocates the
+    // session after acknowledgement, so there is nothing to report yet.
+    return withDispatchOutcome(
+      Response.json(
+        { ok: true, dispatched: true, mode: "turn" },
+        { status: 202 }
+      ),
+      "send"
+    );
+  }
+  return withDispatchOutcome(
+    Response.json({
+      ok: true,
+      sessionId: session.id,
+      isNew: session.isNew,
+      continuationToken: session.continuationToken,
+    }),
+    "send"
+  );
 }
 
 async function resolveCloudOptions(
@@ -812,6 +855,27 @@ export function originChannel(
     ],
   });
   originChannelOptionsByDefinition.set(definition, channelOptions);
+  attachHostedAdmissionAdapter(definition, {
+    kind: ORIGIN_CHANNEL_KIND,
+    dispatch: async ({ payload, args }) => {
+      const envelope = parseOriginWebhookEnvelope(payload);
+      if (envelope === null) {
+        return Response.json(
+          { ok: false, error: "invalid_origin_payload" },
+          { status: 400 }
+        );
+      }
+      return dispatchOriginWebhook({
+        options: channelOptions,
+        envelope,
+        args,
+      });
+    },
+    getOutcome: (response) => {
+      const outcome = getOriginDispatchOutcome(response);
+      return outcome === "skip" || outcome === "task" ? outcome : undefined;
+    },
+  });
   if (usesCursorAccount) {
     registerOriginCursorAccountRuntime(definition, {
       options: channelOptions,

package/src/channels/slack/defaults.ts

@@ -18,6 +18,7 @@ import {
 } from "./constants.js";
 import { createStreamDeliveryStrategy } from "./live-delivery.js";
 import { defaultSlackLog, type SlackLog } from "./log.js";
+import { createProgressDelivery } from "./progress-delivery.js";
 import { buildTaskChunkForResult, buildTaskChunksForCalls } from "./stream.js";
 import type {
   SlackAccessPolicy,
@@ -154,6 +155,10 @@ export function buildDefaultEvents(
   const botToken = credentials?.botToken;
   const getLog = options.getLog ?? (() => defaultSlackLog);
   const strategy = createStreamDeliveryStrategy({ botToken, getLog });
+  const progress = createProgressDelivery({ botToken, getLog });
+
+  const streamLive = (state: SlackChannelState): boolean =>
+    streaming && !state.streamingUnavailable;
 
   const clearWorkingStatus = async (
     channelId: string,
@@ -174,6 +179,62 @@ export function buildDefaultEvents(
     }
   };
 
+  const finishProgress = async (args: {
+    channel: ChannelEventContext<SlackChannelState>;
+    text: string;
+    sessionId: string;
+  }): Promise<boolean> => {
+    const log = getLog();
+    const state = args.channel.state;
+    if (
+      state.channelId === null ||
+      state.threadTs === null ||
+      args.text === ""
+    ) {
+      return false;
+    }
+    if (await progress.replace({ channel: args.channel, text: args.text })) {
+      log.info("reply delivered via progress update", {
+        channel: state.channelId,
+        thread_ts: state.threadTs,
+        session: args.sessionId,
+        chars: args.text.length,
+      });
+      return true;
+    }
+    await progress.clear({ channel: args.channel });
+    try {
+      const posted = await postMessage({
+        botToken,
+        channel: state.channelId,
+        text: args.text,
+        threadTs: state.threadTs,
+      });
+      state.lastPostedText = args.text;
+      state.lastBotMessageTs = posted.ts;
+      log.info("reply delivered via postMessage", {
+        channel: state.channelId,
+        thread_ts: state.threadTs,
+        message_ts: posted.ts,
+        session: args.sessionId,
+        chars: args.text.length,
+      });
+      return true;
+    } catch (error) {
+      log.error(
+        `postMessage failed: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+        {
+          channel: state.channelId,
+          thread_ts: state.threadTs,
+          session: args.sessionId,
+        }
+      );
+      return false;
+    }
+  };
+
   /**
    * Deliver assistant text to the bound Slack thread. Used by a stop-reason
    * `message.completed` and by `turn.completed` when the last assistant
@@ -185,7 +246,6 @@ export function buildDefaultEvents(
     text: string;
     sessionId: string;
   }): Promise<boolean> => {
-    const log = getLog();
     const state = args.channel.state;
     if (
       state.channelId === null ||
@@ -199,8 +259,7 @@ export function buildDefaultEvents(
       // pending. Treat a match as "already on Slack", not "already finalized".
       const streamTs = state.streamTs;
       if (streamTs !== null && streamTs !== "") {
-        const canStream = streaming && state.streamingUnavailable !== true;
-        if (canStream) {
+        if (streamLive(state)) {
           await strategy.finalize({
             channel: args.channel,
             channelId: state.streamChannelId ?? state.channelId,
@@ -214,8 +273,7 @@ export function buildDefaultEvents(
       return true;
     }
 
-    const canStream = streaming && state.streamingUnavailable !== true;
-    if (canStream) {
+    if (streamLive(state)) {
       const { delivered } = await strategy.finalize({
         channel: args.channel,
         channelId: state.streamChannelId ?? state.channelId,
@@ -227,47 +285,20 @@ export function buildDefaultEvents(
       }
     }
 
-    try {
-      const posted = await postMessage({
-        botToken,
-        channel: state.channelId,
-        text: args.text,
-        threadTs: state.threadTs,
-      });
-      state.lastPostedText = args.text;
-      state.lastBotMessageTs = posted.ts;
-      log.info("reply delivered via postMessage", {
-        channel: state.channelId,
-        thread_ts: state.threadTs,
-        message_ts: posted.ts,
-        session: args.sessionId,
-        chars: args.text.length,
-      });
-      return true;
-    } catch (error) {
-      log.error(
-        `postMessage failed: ${
-          error instanceof Error ? error.message : String(error)
-        }`,
-        {
-          channel: state.channelId,
-          thread_ts: state.threadTs,
-          session: args.sessionId,
-        }
-      );
-      return false;
-    }
+    return finishProgress(args);
   };
 
   return {
     async "turn.started"(event, channel) {
       const log = getLog();
+      await progress.clear({ channel });
       channel.state.pendingToolCallMessage = null;
       channel.state.lastReasoningTypingAtMs = null;
       channel.state.lastReasoningTypingStatus = null;
       channel.state.streamTs = null;
       channel.state.streamChannelId = null;
       channel.state.lastPostedText = null;
+      channel.state.streamBlockText = null;
       // Keep lastBotMessageTs across turns — warm delta watermark.
       channel.state.approvalMessageByCallId = {};
 
@@ -293,7 +324,7 @@ export function buildDefaultEvents(
     },
 
     async "message.appended"(event, channel) {
-      if (!streaming || channel.state.streamingUnavailable === true) {
+      if (!streamLive(channel.state)) {
         return;
       }
       const channelId =
@@ -362,8 +393,7 @@ export function buildDefaultEvents(
       if (
         strategy.inlineToolSteps &&
         thinkingSteps &&
-        streaming &&
-        channel.state.streamingUnavailable !== true
+        streamLive(channel.state)
       ) {
         const channelId =
           channel.state.streamChannelId ?? channel.state.channelId;
@@ -403,17 +433,24 @@ export function buildDefaultEvents(
           threadTs: channel.state.threadTs,
           status: statusText,
         });
+        if (
+          thinkingSteps &&
+          channel.state.streamingUnavailable === true &&
+          (channel.state.streamTs === null || channel.state.streamTs === "")
+        ) {
+          await progress.upsert({ channel, text: statusText });
+        }
       }
     },
 
     async "action.result"(event, channel) {
+      const streamTs = channel.state.streamTs;
       if (
         !strategy.inlineToolSteps ||
         !thinkingSteps ||
-        !streaming ||
-        channel.state.streamingUnavailable === true ||
-        channel.state.streamTs === null ||
-        channel.state.streamTs === ""
+        !streamLive(channel.state) ||
+        streamTs === null ||
+        streamTs === ""
       ) {
         return;
       }
@@ -430,7 +467,7 @@ export function buildDefaultEvents(
       await appendChatStream({
         botToken,
         channel: channelId,
-        ts: channel.state.streamTs,
+        ts: streamTs,
         chunks: [chunk],
       });
     },
@@ -439,6 +476,9 @@ export function buildDefaultEvents(
       if (event.data.finishReason === "tool_call") {
         channel.state.pendingToolCallMessage =
           firstNonEmptyLine(event.data.text) ?? null;
+        // The harness restarts its cumulative text after a tool call, so the
+        // next block appends in full instead of diffing against this one.
+        channel.state.streamBlockText = null;
         return;
       }
       channel.state.pendingToolCallMessage = null;
@@ -452,6 +492,7 @@ export function buildDefaultEvents(
       // and clear typing.
       if (event.data.text === "") {
         await strategy.finalizeEmpty({ channel });
+        await progress.clear({ channel });
         await clearWorkingStatus(state.channelId, state.threadTs);
         return;
       }
@@ -492,6 +533,7 @@ export function buildDefaultEvents(
       // Always close leftovers. deliverReplyText may fall through to
       // postMessage when streaming is unavailable and leave streamTs open.
       await strategy.cleanupOrphan({ channel });
+      await progress.clear({ channel });
 
       // Always drop the assistant chip. message.completed already clears
       // after a normal reply, but a tool-call-only finish (or a missed
@@ -539,7 +581,7 @@ export function buildDefaultEvents(
       const errorText = formatSlackTurnFailureMessage(event.data.message);
 
       let delivered = false;
-      if (streaming && state.streamingUnavailable !== true) {
+      if (streamLive(state)) {
         ({ delivered } = await strategy.fail({
           channel,
           channelId: state.streamChannelId ?? state.channelId,
@@ -548,25 +590,11 @@ export function buildDefaultEvents(
         }));
       }
       if (!delivered) {
-        try {
-          await postMessage({
-            botToken,
-            channel: state.channelId,
-            text: errorText,
-            threadTs: state.threadTs,
-          });
-        } catch (error) {
-          log.error(
-            `turn.failed postMessage failed: ${
-              error instanceof Error ? error.message : String(error)
-            }`,
-            {
-              channel: state.channelId,
-              thread_ts: state.threadTs,
-              session: event.sessionId,
-            }
-          );
-        }
+        await finishProgress({
+          channel,
+          text: errorText,
+          sessionId: event.sessionId,
+        });
       }
       await clearWorkingStatus(state.channelId, state.threadTs);
     },

package/src/channels/slack/dispatch.ts

@@ -126,8 +126,10 @@ export function emptySlackChannelState(
     streamTs: null,
     streamChannelId: null,
     lastPostedText: null,
+    streamBlockText: null,
     lastBotMessageTs: null,
     streamingUnavailable: false,
+    progressTs: null,
     approvalMessageByCallId: {},
     ...patch,
   };

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

@@ -41,7 +41,7 @@ type StreamArgs = {
 /**
  * How the default handlers deliver an in-progress reply. Methods write live
  * delivery state (`streamTs`, `streamChannelId`, `lastPostedText`,
- * `streamingUnavailable`) on `channel.state` directly.
+ * `streamBlockText`, `streamingUnavailable`) on `channel.state` directly.
  */
 export interface LiveDeliveryStrategy {
   readonly inlineToolSteps: boolean;
@@ -127,6 +127,7 @@ export function createStreamDeliveryStrategy(
     channel.state.streamTs = started.ts;
     channel.state.streamChannelId = started.channel;
     channel.state.lastPostedText = hasMarkdown ? (markdown_text ?? "") : "";
+    channel.state.streamBlockText = channel.state.lastPostedText;
     log.info("chat.startStream ok", {
       channel: started.channel,
       stream_ts: started.ts,
@@ -167,7 +168,7 @@ export function createStreamDeliveryStrategy(
     text: string;
   }): Promise<{ ok: boolean; error?: string }> => {
     const appendText = computeStreamAppend(
-      args.channel.state.lastPostedText,
+      args.channel.state.streamBlockText,
       args.text
     );
     const stopped = await stopChatStream({
@@ -213,7 +214,7 @@ export function createStreamDeliveryStrategy(
         return;
       }
       const appendText = computeStreamAppend(
-        channel.state.lastPostedText,
+        channel.state.streamBlockText,
         text
       );
       if (appendText === "") {
@@ -238,6 +239,7 @@ export function createStreamDeliveryStrategy(
         return;
       }
       channel.state.lastPostedText = text;
+      channel.state.streamBlockText = text;
     },
 
     async appendChunks({ channel, channelId, chunks, sessionId }) {