@cursor/july 0.1.94 → 0.1.96

package/dist/internal/session-engine.js

@@ -44,6 +44,7 @@ import { createHostFilesApi } from "./host-files.js";
 import { createHostKvApi } from "./host-kv.js";
 import { createHostOtelApi } from "./host-otel.js";
 import { createHostPlatforms, createHostSlackClient, } from "./host-platforms.js";
+import { HostedAdmissionLocalSendError, isDuringHostedAdmission, } from "./hosted-admission-context.js";
 import { formatContinuationToken, newContinuationKey, newSessionId, newToolCallId, parseContinuationToken, } from "./ids.js";
 import { validateToolInput } from "./json-schema.js";
 import { McpHost } from "./mcp-host.js";
@@ -53,6 +54,7 @@ import { assertCloudCanHonorAccountServersFilters } from "./resolved-connections
 import { sessionExternalLinks } from "./session-links.js";
 import { SessionStore } from "./session-store.js";
 import { syncSkillsToStore } from "./skills-sync.js";
+import { steeringEnabled } from "./steering.js";
 import { StorageCoordinator } from "./storage-coordinator.js";
 import { decideToolCall, resolveEffect } from "./tool-policy.js";
 import { normalizeToolResult, toolCallErrorMessage } from "./tool-result.js";
@@ -207,6 +209,7 @@ export class SessionEngine {
         // for why the choice does not belong to the agent author.
         const frameworkStorage = selectFrameworkStorageDefinition({
             authored: options.project.storage,
+            architecture: options.project.agent.architecture,
         });
         this.storage =
             frameworkStorage === undefined
@@ -394,6 +397,9 @@ export class SessionEngine {
                 this.hasBorrowedWorkspace(record)) {
                 return;
             }
+            if (steeringEnabled()) {
+                return;
+            }
             try {
                 yield materializeSlackNudgeCarrier({
                     harnessCwd,
@@ -498,6 +504,13 @@ export class SessionEngine {
         return __awaiter(this, arguments, void 0, function* (channelId, message, options = {}) {
             var _a;
             var _b, _c, _d, _e, _f, _g;
+            if (isDuringHostedAdmission()) {
+                // Only sends that bypassed the admission capture stub (typically a
+                // startup-captured `onStart` send) reach the engine inside the
+                // admission window; running one would leak an invisible local session
+                // on a sessionless pod.
+                throw new HostedAdmissionLocalSendError();
+            }
             const identity = channelId === HTTP_CHANNEL_ID
                 ? httpContinuationIdentity(this.project.httpChannel)
                 : channelContinuationIdentity(this.channelsById.get(channelId));
@@ -892,14 +905,46 @@ export class SessionEngine {
             });
         });
     }
+    steerIntoRunningTurn(sessionId, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.runner.steer === undefined) {
+                return "revert_to_followup";
+            }
+            try {
+                return yield this.runner.steer({ sessionId, text: message });
+            }
+            catch (error) {
+                this.logger(`[session] steer failed for ${sessionId}: ${describeError(error)}`);
+                return "revert_to_followup";
+            }
+        });
+    }
     admitTurn(sessionId_1, message_1) {
         return __awaiter(this, arguments, void 0, function* (sessionId, message, options = {}) {
             var _a;
             const admission = (_a = options.admission) !== null && _a !== void 0 ? _a : "preempt";
+            if (admission === "coalesce" &&
+                steeringEnabled() &&
+                this.isTurnRunning(sessionId)) {
+                const toolCtx = this.activeToolContexts.get(sessionId);
+                const steerOutcome = yield this.steerIntoRunningTurn(sessionId, message);
+                if (steerOutcome === "complete_delivered") {
+                    this.logger(`[session] steered into running turn ${sessionId}`);
+                    if (toolCtx !== undefined) {
+                        toolCtx.emit({ type: "message.received", data: { text: message } });
+                        toolCtx.emit({ type: "nudge.delivered", data: {} });
+                    }
+                    return true;
+                }
+            }
+            // Re-checked after the steer: a turn that ended during it falls through
+            // and this message starts the next turn itself. Enqueueing here instead
+            // would orphan it — the completion drain already ran.
             if (admission === "coalesce" && this.isTurnRunning(sessionId)) {
-                this.enqueueCoalesced(sessionId, Object.assign({ message }, (options.sourceTs === undefined
-                    ? {}
-                    : { sourceTs: options.sourceTs })));
+                this.enqueueCoalesced(sessionId, {
+                    message,
+                    sourceTs: options.sourceTs,
+                });
                 this.logger(`[session] coalesce enqueue ${sessionId}`);
                 return true;
             }
@@ -2504,6 +2549,29 @@ export class SessionEngine {
     // ==========================================================================
     // Session handles
     // ==========================================================================
+    /**
+     * Wait until everything this session has already emitted is durably
+     * mirrored: its dispatch chain first (the chain's tail runs the turn-end
+     * storage flush, so the record carries the boundary event's handler
+     * mutations), then the storage delivery queue. Hosted v2 awaits this
+     * before the execution reply — the pod can be parked the moment the
+     * reply lands, and an unflushed session record would strand a
+     * conversation whose blobs persisted but whose record (which selects the
+     * conversation to hydrate) never reached the sink. No-op without a
+     * storage mirror.
+     */
+    drainSessionDurability(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.storage === undefined) {
+                return;
+            }
+            const chain = this.dispatchChains.get(sessionId);
+            if (chain !== undefined) {
+                yield chain.catch(() => { });
+            }
+            yield this.storage.whenIdle();
+        });
+    }
     waitForCompletion(sessionId) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;

package/dist/internal/steering.d.ts

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

package/dist/internal/steering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"steering.d.ts","sourceRoot":"","sources":["../../src/internal/steering.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAGzC"}

package/dist/internal/steering.js

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