@cursor/july 0.1.111 → 0.1.113

package/src/internal/discovery/extensions.ts

@@ -15,6 +15,7 @@ import type {
   DiscoveredSchedule,
   DiscoveredSkill,
   DiscoveredTool,
+  ExtensionContributionSelection,
   ExtensionMount,
   ResolvedAgent,
   SeedFile,
@@ -450,18 +451,25 @@ async function readExtensionTree(
       seedFiles: [],
     };
   }
-  return readNativeTree(ctx, root);
+  return readNativeTree(ctx, root, mount.contributions);
 }
 
 async function readNativeTree(
   ctx: DiscoveryContext,
-  root: string
+  root: string,
+  contributions?: ExtensionContributionSelection
 ): Promise<ExtensionTree> {
   await warnAgentRootOnlySlots(ctx, root);
   const connections = await loadConnections(ctx, join(root, "mcp-connections"));
   return {
-    tools: await loadTools(ctx, join(root, "tools")),
-    skills: await loadSkills(ctx, join(root, "skills")),
+    tools:
+      contributions?.tools === false
+        ? []
+        : await loadTools(ctx, join(root, "tools")),
+    skills:
+      contributions?.skills === false
+        ? []
+        : await loadSkills(ctx, join(root, "skills")),
     connections,
     hostConnections: await loadHostConnections(ctx, root, connections),
     overlaidServers: [],

package/src/internal/discovery/info.ts

@@ -80,6 +80,7 @@ export function projectInfo(project: AgentProject): AgentProjectInfo {
       name: connection.name,
       transport: connectionTransportLabel(connection.transport),
       advertiseTools: connection.advertiseTools,
+      optional: connection.optional,
       effects: connection.effects,
       tools: connection.tools,
       disallowedTools: connection.disallowedTools,

package/src/internal/filesystem/tools.ts

@@ -12,6 +12,7 @@ import { z } from "zod";
 import {
   canonicalizeFileSystemToolName,
   collectGrepMatches,
+  FILE_SYSTEM_SCAN_LIMIT,
   type FileSystem,
   type FileSystemToolName,
   fileSystemImage,
@@ -534,6 +535,7 @@ Tool to search for files matching a glob pattern
           await collectGlob(root, {
             pattern: globPattern,
             ...(targetDirectory === undefined ? {} : { dir: targetDirectory }),
+            limit: FILE_SYSTEM_SCAN_LIMIT,
           })
         ).map(entry => entry.path);
         return formatGlobOutput(dir, files);

package/src/internal/filesystem/walk.ts

@@ -7,8 +7,14 @@
 
 import { posix } from "node:path";
 import { minimatch } from "minimatch";
-import type { DirEntry, FileInfo, FileSystem } from "../../filesystem.js";
-import { normalizeFsPath } from "../../filesystem.js";
+import type {
+  DirEntry,
+  FileInfo,
+  FileSystem,
+  GlobOptions,
+  ListOptions,
+} from "../../filesystem.js";
+import { FILE_SYSTEM_SCAN_LIMIT, normalizeFsPath } from "../../filesystem.js";
 import { mergeSorted } from "./merge.js";
 
 /**
@@ -29,13 +35,22 @@ export interface LsDirectoryTreeNode {
 /** Filename-character ingest budget; matches LocalLsExecutor. */
 export const LS_INGEST_CHARACTER_BUDGET = 2_500;
 
+function takeLimit(entries: readonly DirEntry[], limit?: number): DirEntry[] {
+  if (limit === undefined || !Number.isFinite(limit)) {
+    return [...entries];
+  }
+  const cap = Math.max(0, Math.floor(limit));
+  return entries.slice(0, cap);
+}
+
 /**
  * Yield the files under `prefix`, sorted. A file whose path equals
  * `prefix` is not under itself.
  */
 export async function* listFilesFromPaths(
   files: Iterable<DirEntry>,
-  prefix?: string
+  prefix?: string,
+  options?: ListOptions
 ): AsyncGenerator<DirEntry> {
   const scope = normalizeListPrefix(prefix);
   const withSlash = scope === "/" ? "/" : `${scope}/`;
@@ -60,7 +75,7 @@ export async function* listFilesFromPaths(
     );
   }
   matches.sort((left, right) => left.path.localeCompare(right.path));
-  yield* matches;
+  yield* takeLimit(applyIgnores(matches, options?.excludes), options?.limit);
 }
 
 export function normalizeListPrefix(prefix?: string): string {
@@ -97,13 +112,14 @@ export function statFromFilePaths(
 
 export async function collectList(
   root: Pick<FileSystem, "list">,
-  prefix?: string
+  prefix?: string,
+  options?: ListOptions
 ): Promise<DirEntry[]> {
   const entries: DirEntry[] = [];
   if (root.list === undefined) {
     return entries;
   }
-  for await (const entry of root.list(prefix)) {
+  for await (const entry of root.list(prefix, options)) {
     entries.push(entry);
   }
   return entries;
@@ -111,13 +127,19 @@ export async function collectList(
 
 export async function collectGlob(
   root: Pick<FileSystem, "glob">,
-  options: { pattern: string; dir?: string }
+  options: { pattern: string; dir?: string; limit?: number }
 ): Promise<DirEntry[]> {
   const entries: DirEntry[] = [];
   if (root.glob === undefined) {
     return entries;
   }
-  for await (const entry of root.glob(options.pattern, options.dir)) {
+  const globOptions: GlobOptions | undefined =
+    options.limit === undefined ? undefined : { limit: options.limit };
+  for await (const entry of root.glob(
+    options.pattern,
+    options.dir,
+    globOptions
+  )) {
     entries.push(entry);
   }
   return entries;
@@ -129,9 +151,10 @@ export async function collectGlob(
  */
 export async function collectListOrStat(
   root: Pick<FileSystem, "list" | "stat">,
-  path?: string
+  path?: string,
+  options?: ListOptions
 ): Promise<{ kind: FileInfo["kind"]; files: DirEntry[] }> {
-  const files = await collectList(root, path);
+  const files = await collectList(root, path, options);
   if (files.length > 0) {
     return { kind: "directory", files };
   }
@@ -298,10 +321,27 @@ function matchesIgnoreGlob(filePath: string, glob: string): boolean {
     ? glob
     : recursivePrefix + glob;
   const relative = filePath.replace(/^\//, "");
-  return (
-    minimatch(relative, pattern, { dot: true }) ||
-    minimatch(filePath, pattern, { dot: true })
-  );
+  const candidates = [relative, filePath];
+  for (const candidate of candidates) {
+    if (
+      minimatch(candidate, pattern, { dot: true }) ||
+      minimatch(candidate, `${pattern}/**`, { dot: true })
+    ) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/** True when `path` matches any {@link ListOptions.excludes} glob. */
+export function isExcludedPath(
+  path: string,
+  excludes?: readonly string[]
+): boolean {
+  if (excludes === undefined || excludes.length === 0) {
+    return false;
+  }
+  return excludes.some(glob => matchesIgnoreGlob(path, glob));
 }
 
 export async function lsFromList(
@@ -312,7 +352,12 @@ export async function lsFromList(
   | { status: "success"; value: { directoryTreeRoot: LsDirectoryTreeNode } }
   | { status: "error"; error: { message: string } }
 > {
-  const listed = await collectListOrStat(root, path);
+  const listed = await collectListOrStat(root, path, {
+    limit: FILE_SYSTEM_SCAN_LIMIT,
+    ...(ignoreGlobs === undefined || ignoreGlobs.length === 0
+      ? {}
+      : { excludes: ignoreGlobs }),
+  });
   const treePath = path ?? inferListedRoot(listed.files);
   switch (listed.kind) {
     case "missing":

package/src/internal/hosted-admission-adapter.ts

@@ -1,4 +1,5 @@
 import type { ChannelHandlerArgs } from "../types.js";
+import type { HostedAdmissionPlatformHandoff } from "./hosted-delivery-protocol.js";
 
 /**
  * Hosted-admission hook a channel pack attaches to its definition.
@@ -27,6 +28,8 @@ export type HostedAdmissionAdapter = {
     args: ChannelHandlerArgs;
     /** Mailbox key the control plane already allocated for this admission. */
     mailboxContinuationKey?: string;
+    /** Trusted control-plane handoff (Slack placeholder ts, …). */
+    platformHandoff?: HostedAdmissionPlatformHandoff;
   }): Promise<Response>;
 };
 

package/src/internal/hosted-delivery-protocol.ts

@@ -149,6 +149,8 @@ export type HostedGuestError = {
   classification: HostedFailureClassification;
   message?: string;
   turnStatus?: string;
+  /** Runner/SDK code (`unknown`, `canceled`, …). Not the human message. */
+  errorCode?: string;
 };
 
 /**
@@ -162,6 +164,7 @@ export function hostedGuestErrorResponse(input: {
   retry: HostedGuestRetryDisposition;
   message?: string;
   turnStatus?: string;
+  errorCode?: string;
 }): Response {
   const body: HostedGuestError = {
     ok: false,
@@ -170,6 +173,7 @@ export function hostedGuestErrorResponse(input: {
     classification: hostedFailureClassification(input.error),
     message: input.message,
     turnStatus: input.turnStatus,
+    errorCode: input.errorCode,
   };
   return Response.json(body, { status: input.status });
 }
@@ -236,6 +240,20 @@ export type HostedAdmissionManagedAutomation = {
   slackChannels?: string[];
 };
 
+/**
+ * Trusted control-plane handoff for a Slack placeholder posted at ingress
+ * before the Temporal signal. Omitted when no placeholder was posted.
+ */
+export type HostedAdmissionPlatformHandoff = {
+  v: 1;
+  slackPlaceholder: {
+    messageTs: string;
+    channelId: string;
+    threadTs: string;
+    streamed: false;
+  };
+};
+
 export type HostedAdmission = {
   v: 2;
   channelId: string;
@@ -251,6 +269,8 @@ export type HostedAdmission = {
   mailboxContinuationKey: string;
   payload: unknown;
   managedAutomation?: HostedAdmissionManagedAutomation;
+  /** Present only when control-plane Slack fast-act posted a placeholder. */
+  platformHandoff?: HostedAdmissionPlatformHandoff;
 };
 
 export type HostedAdmissionOutcome =
@@ -304,12 +324,19 @@ const DELIVERY_KEYS = new Set([
   "mailboxContinuationKey",
   "payload",
   "managedAutomation",
+  "platformHandoff",
 ]);
 const MANAGED_AUTOMATION_KEYS = new Set([
   "automationUuid",
   "mcpServerNames",
   "slackChannels",
 ]);
+export const HOSTED_PLATFORM_HANDOFF_KEYS: ReadonlySet<string> = new Set([
+  "v",
+  "slackPlaceholder",
+]);
+export const HOSTED_SLACK_PLACEHOLDER_HANDOFF_KEYS: ReadonlySet<string> =
+  new Set(["messageTs", "channelId", "threadTs", "streamed"]);
 /** More names than any real automation configures is a malformed envelope. */
 const MANAGED_AUTOMATION_MAX_SERVERS = 64;
 /** More channels than the dashboard picker allows is a malformed envelope. */
@@ -370,6 +397,59 @@ function parseManagedAutomation(
   };
 }
 
+/**
+ * Parse optional control-plane Slack placeholder handoff. Absent → valid;
+ * present-but-malformed → invalid (fail closed like managedAutomation).
+ */
+function parsePlatformHandoff(
+  value: unknown
+): { platformHandoff?: HostedAdmissionPlatformHandoff } | undefined {
+  if (value === undefined) {
+    return {};
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return undefined;
+  }
+  const body = value as Record<string, unknown>;
+  if (
+    Object.keys(body).some(key => !HOSTED_PLATFORM_HANDOFF_KEYS.has(key)) ||
+    body.v !== 1
+  ) {
+    return undefined;
+  }
+  const placeholder = body.slackPlaceholder;
+  if (
+    typeof placeholder !== "object" ||
+    placeholder === null ||
+    Array.isArray(placeholder)
+  ) {
+    return undefined;
+  }
+  const slot = placeholder as Record<string, unknown>;
+  if (
+    Object.keys(slot).some(
+      key => !HOSTED_SLACK_PLACEHOLDER_HANDOFF_KEYS.has(key)
+    ) ||
+    !boundedString(slot.messageTs, 64) ||
+    !boundedString(slot.channelId, 64) ||
+    !boundedString(slot.threadTs, 64) ||
+    slot.streamed !== false
+  ) {
+    return undefined;
+  }
+  return {
+    platformHandoff: {
+      v: 1,
+      slackPlaceholder: {
+        messageTs: slot.messageTs,
+        channelId: slot.channelId,
+        threadTs: slot.threadTs,
+        streamed: slot.streamed,
+      },
+    },
+  };
+}
+
 export function parseHostedAdmission(
   value: unknown
 ): HostedAdmission | undefined {
@@ -387,7 +467,8 @@ export function parseHostedAdmission(
     !boundedString(body.deliveryId, 256) ||
     (body.sessionMode !== "event" && body.sessionMode !== "continuation") ||
     !boundedString(body.mailboxContinuationKey, 512) ||
-    parseManagedAutomation(body.managedAutomation) === undefined
+    parseManagedAutomation(body.managedAutomation) === undefined ||
+    parsePlatformHandoff(body.platformHandoff) === undefined
   ) {
     return undefined;
   }

package/src/internal/hosted-delivery.ts

@@ -14,6 +14,7 @@ import {
   createDeferredChannelSession,
   DeferredChannelSessionError,
 } from "./deferred-channel-session.js";
+import { describeErrorCode } from "./describe-error.js";
 import {
   formatGuestNetworkServerTiming,
   GUEST_CONNECT_STALLED,
@@ -391,6 +392,7 @@ async function runAdmission(
       deliveryId: input.delivery.deliveryId,
       args,
       mailboxContinuationKey: input.delivery.mailboxContinuationKey,
+      platformHandoff: input.delivery.platformHandoff,
     });
   } catch (error) {
     const mapped = mappedAdmissionFailure(error);
@@ -888,6 +890,7 @@ export function registerHostedDeliveryRoute(input: {
               | ReturnType<typeof abortReasonFromTurnStatus>
               | "execute_throw";
             failureCode?: string;
+            errorCode?: string;
             error?: unknown;
           }): Promise<void> => {
             const classification =
@@ -910,6 +913,9 @@ export function registerHostedDeliveryRoute(input: {
                 ? {}
                 : { abortReason: fields.abortReason }),
               failureCode: fields.failureCode,
+              ...(fields.errorCode === undefined
+                ? {}
+                : { errorCode: fields.errorCode }),
               classification,
               ...(fields.error === undefined ? {} : { error: fields.error }),
             });
@@ -948,6 +954,13 @@ export function registerHostedDeliveryRoute(input: {
                   },
                 });
                 sessionId = session.id;
+                // The pre-turn claim used an empty sessionId. Stamp the
+                // engine id now so a dashboard / session-view poll that
+                // only has the factory `ses_…` can follow `session-events/`.
+                await writeDiag({
+                  sessionId,
+                  turnStatus: HOSTED_EXECUTION_DIAG_RUNNING_STATUS,
+                });
                 const outcome = await session.waitForCompletion();
                 completionAt = hostedExecutionNow();
                 // Status is the owner turn. waitForCompletion still waited
@@ -996,6 +1009,9 @@ export function registerHostedDeliveryRoute(input: {
                     outcome.cancellationReason
                   ),
                   failureCode: hostedFailure?.error,
+                  ...(outcome.errorCode === undefined
+                    ? {}
+                    : { errorCode: outcome.errorCode }),
                 });
                 const reply =
                   hostedFailure !== undefined
@@ -1010,6 +1026,9 @@ export function registerHostedDeliveryRoute(input: {
                           ),
                           turnStatus: outcome.status,
                           message: outcome.errorMessage,
+                          ...(outcome.errorCode === undefined
+                            ? {}
+                            : { errorCode: outcome.errorCode }),
                         },
                       }
                     : {
@@ -1039,6 +1058,7 @@ export function registerHostedDeliveryRoute(input: {
                   sessionId,
                   execution.sessionPublicId
                 );
+                const thrownErrorCode = describeErrorCode(error);
                 await writeDiag({
                   sessionId: "",
                   turnStatus: "error",
@@ -1047,6 +1067,9 @@ export function registerHostedDeliveryRoute(input: {
                   abortReason: "execute_throw",
                   failureCode: "internal_error",
                   error,
+                  ...(thrownErrorCode === undefined
+                    ? {}
+                    : { errorCode: thrownErrorCode }),
                 });
                 const endedAt = hostedExecutionNow();
                 // Preserve completion/drain marks when the failure happened

package/src/internal/hosted-execution-diag.ts

@@ -43,7 +43,8 @@ export type HostedExecutionDiagAbortReason =
 /**
  * Bounded guest-side record of one hosted-execution attempt. No prompt,
  * tool content, or API key — the host copies known keys onto the Temporal
- * activity span for Datadog.
+ * activity span for Datadog. `errorCode` and `message` are logged ungated;
+ * `stack` stays behind the internal-diag gate.
  */
 export type HostedExecutionDiag = {
   v: typeof HOSTED_EXECUTION_DIAG_VERSION;
@@ -62,6 +63,8 @@ export type HostedExecutionDiag = {
   requestId?: string;
   abortReason?: HostedExecutionDiagAbortReason;
   failureCode?: string;
+  /** Runner/SDK code for the unfinished turn. Distinct from {@link failureCode}. */
+  errorCode?: string;
   classification?: HostedFailureClassification;
 };
 
@@ -82,6 +85,7 @@ const DIAG_KEYS = new Set([
   "requestId",
   "abortReason",
   "failureCode",
+  "errorCode",
   "classification",
 ]);
 
@@ -108,9 +112,9 @@ export const HOSTED_ERROR_STACK_LINE_COUNT = 5;
 export const HOSTED_ERROR_SNIPPET_MAX_CHARS = 700;
 
 /**
- * Bounded throw text for the hosted 500 body and the on-disk diag `stack`.
- * Prefers `Error.stack` (message line + `at` frames) so `last_error` is not
- * the generic "Internal server error." when the throw has a stack.
+ * Bounded throw text for on-disk diag `stack` (and non-hosted 500 bodies).
+ * Prefers `Error.stack` (message line + `at` frames). Hosted HTTP `message`
+ * uses {@link hostedErrorMessageOnly} so customer Datadog stays frame-free.
  */
 export function hostedErrorStackSnippet(error: unknown): string {
   if (error instanceof Error) {
@@ -139,6 +143,29 @@ export function hostedErrorStackSnippet(error: unknown): string {
     : text;
 }
 
+/**
+ * Guest throw text without `at` frames. Hosted 500 `message` is ungated on
+ * TAS (`hostedGuestMessage` / `last_error`); stack frames stay on `stack`.
+ */
+export function hostedErrorMessageOnly(error: unknown): string {
+  const text =
+    error instanceof Error && error.message.trim().length > 0
+      ? error.message.trim()
+      : String(error).trim();
+  if (text.length === 0) {
+    return "Internal server error.";
+  }
+  const firstFrame = text.search(/\n\s+at\s/);
+  const message =
+    firstFrame === -1 ? text : text.slice(0, firstFrame).trimEnd();
+  if (message.length === 0) {
+    return "Internal server error.";
+  }
+  return message.length > HOSTED_ERROR_SNIPPET_MAX_CHARS
+    ? `${message.slice(0, HOSTED_ERROR_SNIPPET_MAX_CHARS)}…`
+    : message;
+}
+
 export function hostedExecutionDiagPath(stateRoot: string): string {
   return join(stateRoot, HOSTED_EXECUTION_DIAG_FILENAME);
 }
@@ -206,6 +233,7 @@ export function parseHostedExecutionDiag(
   );
   const requestId = boundedOptionalString(body.requestId, 128);
   const failureCode = boundedOptionalString(body.failureCode, 64);
+  const errorCode = boundedOptionalString(body.errorCode, 64);
   const classification =
     body.classification === undefined
       ? undefined
@@ -243,6 +271,7 @@ export function parseHostedExecutionDiag(
     ...(requestId === undefined ? {} : { requestId }),
     ...(abortReason === undefined ? {} : { abortReason }),
     ...(failureCode === undefined ? {} : { failureCode }),
+    ...(errorCode === undefined ? {} : { errorCode }),
     ...(classification === undefined ? {} : { classification }),
   };
 }

package/src/internal/hosted-execution-flush.ts

@@ -48,6 +48,7 @@ export type HostedExecutionFlushFields = {
   message?: string;
   abortReason?: HostedExecutionDiagAbortReason;
   failureCode?: string;
+  errorCode?: string;
   classification?: HostedFailureClassification;
   error?: unknown;
 };
@@ -83,6 +84,9 @@ export async function flushHostedExecutionRecord(
         ? {}
         : { abortReason: fields.abortReason }),
       failureCode: fields.failureCode,
+      ...(fields.errorCode === undefined
+        ? {}
+        : { errorCode: fields.errorCode }),
       classification: fields.classification,
     });
   }

package/src/internal/init-project.ts

@@ -81,6 +81,8 @@ const TEMPLATES: Readonly<Record<TemplateName, TemplateEntry>> = {
   "pr-autofixer": { dir: "pr-autofixer" },
   "security-help": { dir: "security-help" },
   "security-reviewer": { dir: "security-reviewer" },
+  "thermo-quality-review": { dir: "thermo-quality-review" },
+  "thermo-review": { dir: "thermo-review" },
   "triage-linear": { dir: "triage", overlay: "linear" },
   "triage-jira": { dir: "triage", overlay: "jira" },
 };
@@ -714,6 +716,8 @@ Scaffold a project, then open the playground:
   npx ${PACKAGE_NAME} init ./code-wiki --template code-wiki       # keep wiki pages current after merge
   npx ${PACKAGE_NAME} init ./agents-md --template agents-md       # keep AGENTS.md current from last week's PRs and Slack
   npx ${PACKAGE_NAME} init ./my-reviewer --template security-reviewer   # review PRs for security bugs
+  npx ${PACKAGE_NAME} init ./thermo-review --template thermo-review       # review PRs for bugs and breakage
+  npx ${PACKAGE_NAME} init ./thermo-quality --template thermo-quality-review # review PRs for code quality
   npx ${PACKAGE_NAME} init ./security-help --template security-help   # answer security questions in Slack
   npx ${PACKAGE_NAME} init ./my-triage --template triage-linear   # comment on Linear issues
   npx ${PACKAGE_NAME} init ./my-triage --template triage-jira     # comment on Jira issues