@cursor/july 0.1.96 → 0.1.99

package/dist/internal/hosted-delivery.d.ts

@@ -1,6 +1,8 @@
 import type { ChannelHandlerArgs, SendMessageOptions } from "../types.js";
 import { type HostedAdmission } from "./hosted-delivery-protocol.js";
+import type { LogRingEntry } from "./log-ring.js";
 import type { Router } from "./router.js";
+import { type SessionRunExecutionWrite } from "./session-run-log.js";
 type DispatchInput = {
     delivery: HostedAdmission;
     definition: object;
@@ -17,11 +19,14 @@ type AdmissionDispatch = {
     pendingSend?: PendingSend;
 };
 /**
- * Run authored admission without creating a framework session. V1 GitHub
+ * Run authored admission without creating a framework session. Authored
  * `task` callbacks execute as sessionless work; the first `send` is captured
  * and executed only after the control plane allocates `ses_…`. Capturing
  * does not terminate the caller — `send` returns an inert deferred handle so
  * a task body runs to completion before the admission response is computed.
+ *
+ * Dispatch is the adapter the mounted channel attached. Hosted delivery
+ * does not switch on `channelKind`.
  */
 export declare function dispatchHostedAdmission(input: DispatchInput): Promise<AdmissionDispatch>;
 export declare function registerHostedDeliveryRoute(input: {
@@ -39,6 +44,21 @@ export declare function registerHostedDeliveryRoute(input: {
      * the conversation on the next wake.
      */
     drainSessionDurability?(sessionId: string): Promise<void>;
+    /**
+     * Serve `--state-root` (not the per-slug SessionEngine dir). Hosted
+     * freeze is `/workspace/.agent-serve`; the Temporal host reads
+     * `hosted-execution.json` from that path after the POST returns.
+     */
+    stateRoot?: string;
+    /**
+     * Upsert this execution into the v2 session-level framework-store log.
+     * Called for the pre-turn `running` claim and every terminal outcome so
+     * a dead Node process still leaves a leftover. Soft-fail inside the
+     * store; this path still awaits so a parked pod cannot shed the write.
+     */
+    persistSessionRun?(write: SessionRunExecutionWrite): Promise<void>;
+    /** Snapshot of the process log ring at persist time. */
+    snapshotLogs?(): LogRingEntry[];
 }): void;
 export {};
 //# sourceMappingURL=hosted-delivery.d.ts.map

package/dist/internal/hosted-delivery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hosted-delivery.d.ts","sourceRoot":"","sources":["../../src/internal/hosted-delivery.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAEV,kBAAkB,EAClB,kBAAkB,EACnB,MAAM,aAAa,CAAC;AASrB,OAAO,EAKL,KAAK,eAAe,EAGrB,MAAM,+BAA+B,CAAC;AAGvC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C,KAAK,aAAa,GAAG;IACnB,QAAQ,EAAE,eAAe,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,kBAAkB,CAAC;CAC1B,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,kBAAkB,CAAC;IAC5B,sBAAsB,EAAE,MAAM,CAAC;CAChC,CAAC;AAEF,KAAK,iBAAiB,GAAG;IACvB,QAAQ,EAAE,QAAQ,CAAC;IACnB,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B,CAAC;AA6DF;;;;;;GAMG;AACH,wBAAsB,uBAAuB,CAC3C,KAAK,EAAE,aAAa,GACnB,OAAO,CAAC,iBAAiB,CAAC,CAa5B;AA2GD,wBAAgB,2BAA2B,CAAC,KAAK,EAAE;IACjD,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACpD,gBAAgB,CACd,SAAS,EAAE,MAAM,EACjB,eAAe,CAAC,EAAE,MAAM,GACvB,kBAAkB,CAAC;IACtB;;;;;OAKG;IACH,sBAAsB,CAAC,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3D,GAAG,IAAI,CAyKP"}
+{"version":3,"file":"hosted-delivery.d.ts","sourceRoot":"","sources":["../../src/internal/hosted-delivery.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,kBAAkB,EAClB,kBAAkB,EACnB,MAAM,aAAa,CAAC;AAarB,OAAO,EAKL,KAAK,eAAe,EAGrB,MAAM,+BAA+B,CAAC;AAUvC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EACL,KAAK,wBAAwB,EAG9B,MAAM,sBAAsB,CAAC;AAE9B,KAAK,aAAa,GAAG;IACnB,QAAQ,EAAE,eAAe,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,kBAAkB,CAAC;CAC1B,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,kBAAkB,CAAC;IAC5B,sBAAsB,EAAE,MAAM,CAAC;CAChC,CAAC;AAEF,KAAK,iBAAiB,GAAG;IACvB,QAAQ,EAAE,QAAQ,CAAC;IACnB,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B,CAAC;AA6DF;;;;;;;;;GASG;AACH,wBAAsB,uBAAuB,CAC3C,KAAK,EAAE,aAAa,GACnB,OAAO,CAAC,iBAAiB,CAAC,CAa5B;AA2GD,wBAAgB,2BAA2B,CAAC,KAAK,EAAE;IACjD,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACpD,gBAAgB,CACd,SAAS,EAAE,MAAM,EACjB,eAAe,CAAC,EAAE,MAAM,GACvB,kBAAkB,CAAC;IACtB;;;;;OAKG;IACH,sBAAsB,CAAC,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1D;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,iBAAiB,CAAC,CAAC,KAAK,EAAE,wBAAwB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnE,wDAAwD;IACxD,YAAY,CAAC,IAAI,YAAY,EAAE,CAAC;CACjC,GAAG,IAAI,CAyQP"}

package/dist/internal/hosted-delivery.js

@@ -8,12 +8,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { randomBytes } from "node:crypto";
-import { dispatchGitHubWebhook, getGitHubChannelOptions, getGitHubDispatchOutcome, withPropagatingGitHubBackgroundErrors, } from "../channels/github/github-channel.js";
 import { createDeferredChannelSession, DeferredChannelSessionError, } from "./deferred-channel-session.js";
+import { getHostedAdmissionAdapter, } from "./hosted-admission-adapter.js";
 import { HostedAdmissionLocalSendError, runDuringHostedAdmission, } from "./hosted-admission-context.js";
 import { HOSTED_ADMISSION_PATH, HOSTED_DELIVERY_HEADER, HOSTED_DELIVERY_PROTOCOL_VERSION, HOSTED_EXECUTION_PATH, parseHostedAdmission, parseHostedExecution, } from "./hosted-delivery-protocol.js";
+import { abortReasonFromTurnStatus, HOSTED_EXECUTION_DIAG_RUNNING_STATUS, hostedErrorStackSnippet, hostedExecutionDiagId, writeHostedExecutionDiag, } from "./hosted-execution-diag.js";
 import { recordHostedManagedAutomation } from "./hosted-managed-automation.js";
 import { errorResponse, readJsonObject } from "./http-channel.js";
+import { serializeSessionRunError, snapshotSessionRunLogs, } from "./session-run-log.js";
 /**
  * A second `send()` in one delivery is a deterministic authored bug — the
  * wire protocol carries exactly one pending send per delivery — so it must
@@ -58,30 +60,35 @@ function nonRetryableRejection(error) {
     };
 }
 /**
- * Run authored admission without creating a framework session. V1 GitHub
+ * Run authored admission without creating a framework session. Authored
  * `task` callbacks execute as sessionless work; the first `send` is captured
  * and executed only after the control plane allocates `ses_…`. Capturing
  * does not terminate the caller — `send` returns an inert deferred handle so
  * a task body runs to completion before the admission response is computed.
+ *
+ * Dispatch is the adapter the mounted channel attached. Hosted delivery
+ * does not switch on `channelKind`.
  */
 export function dispatchHostedAdmission(input) {
     return __awaiter(this, void 0, void 0, function* () {
-        const github = getGitHubChannelOptions(input.definition);
-        if (github === undefined) {
+        const adapter = getHostedAdmissionAdapter(input.definition);
+        if (adapter === undefined || adapter.kind !== input.delivery.channelKind) {
             return {
                 response: Response.json({ ok: false, error: "channel_kind_mismatch" }, { status: 422 }),
             };
         }
         // The admission window marker follows the async graph into task bodies so
         // the engine can refuse local sends that would bypass the capture stub.
-        return runDuringHostedAdmission(() => runAdmission(input, github));
+        return runDuringHostedAdmission(() => runAdmission(input, adapter));
     });
 }
-function runAdmission(input, github) {
+function runAdmission(input, adapter) {
     return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        var _b;
         const background = [];
         let captured;
-        const args = withPropagatingGitHubBackgroundErrors(Object.assign(Object.assign({}, input.args), { send: (message_1, ...args_1) => __awaiter(this, [message_1, ...args_1], void 0, function* (message, options = {}) {
+        const capturingArgs = Object.assign(Object.assign({}, input.args), { send: (message_1, ...args_1) => __awaiter(this, [message_1, ...args_1], void 0, function* (message, options = {}) {
                 if (captured !== undefined) {
                     throw new HostedSendLimitExceeded();
                 }
@@ -89,12 +96,12 @@ function runAdmission(input, github) {
                 return createDeferredChannelSession();
             }), waitUntil: (promise) => {
                 background.push(promise);
-            } }));
+            } });
+        const args = (_b = (_a = adapter.prepareArgs) === null || _a === void 0 ? void 0 : _a.call(adapter, capturingArgs)) !== null && _b !== void 0 ? _b : capturingArgs;
         let dispatched;
         try {
-            dispatched = yield dispatchGitHubWebhook({
-                options: github,
-                eventName: input.delivery.eventType,
+            dispatched = yield adapter.dispatch({
+                eventType: input.delivery.eventType,
                 payload: input.delivery.payload,
                 deliveryId: input.delivery.deliveryId,
                 args,
@@ -139,7 +146,7 @@ function runAdmission(input, github) {
                 },
             };
         }
-        const outcome = getGitHubDispatchOutcome(dispatched);
+        const outcome = adapter.getOutcome(dispatched);
         if (outcome === undefined) {
             return {
                 response: Response.json({ ok: false, error: "channel_outcome_missing" }, { status: 502 }),
@@ -248,33 +255,93 @@ export function registerHostedDeliveryRoute(input) {
             admitted.sessionPublicId = execution.sessionPublicId;
             (_a = admitted.execution) !== null && _a !== void 0 ? _a : (admitted.execution = (() => __awaiter(this, void 0, void 0, function* () {
                 var _a;
-                const args = input.buildHandlerArgs(admitted.send.channelId, execution.sessionPublicId);
-                const session = yield args.send(admitted.send.message, Object.assign(Object.assign({}, admitted.send.options), { mailboxContinuation: {
-                        key: admitted.send.mailboxContinuationKey,
-                    } }));
-                const outcome = yield session.waitForCompletion();
-                // Failed turns drain too: their record/continuation updates must
-                // survive the park just like a finished turn's.
-                yield (_a = input.drainSessionDurability) === null || _a === void 0 ? void 0 : _a.call(input, session.id);
-                if (outcome.status !== "finished") {
+                const startedAt = performance.now();
+                const executionId = hostedExecutionDiagId(execution.admissionToken);
+                const writeDiag = (fields) => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    var _b;
+                    const durationMs = Math.max(0, Math.round(performance.now() - startedAt));
+                    const message = fields.message === undefined
+                        ? undefined
+                        : boundedMessage(fields.message);
+                    const stack = fields.error === undefined
+                        ? undefined
+                        : hostedErrorStackSnippet(fields.error);
+                    if (input.stateRoot !== undefined) {
+                        yield writeHostedExecutionDiag(input.stateRoot, Object.assign(Object.assign(Object.assign(Object.assign({ v: 1, executionId, writtenAt: new Date().toISOString(), sessionPublicId: execution.sessionPublicId, sessionId: fields.sessionId, turnStatus: fields.turnStatus, durationMs }, (message === undefined ? {} : { message })), (stack === undefined || stack.length === 0 ? {} : { stack })), (message !== undefined && /abort/i.test(message)
+                            ? { signalAborted: true }
+                            : {})), (fields.abortReason === undefined
+                            ? {}
+                            : { abortReason: fields.abortReason })));
+                    }
+                    if (input.persistSessionRun === undefined) {
+                        return;
+                    }
+                    const error = fields.error === undefined
+                        ? undefined
+                        : serializeSessionRunError(fields.error);
+                    try {
+                        yield input.persistSessionRun(Object.assign(Object.assign(Object.assign(Object.assign({ executionId, writtenAt: new Date().toISOString(), sessionPublicId: execution.sessionPublicId, sessionId: fields.sessionId, turnStatus: fields.turnStatus, durationMs }, (fields.abortReason === undefined
+                            ? {}
+                            : { abortReason: fields.abortReason })), (message === undefined ? {} : { message })), (error === undefined ? {} : { error })), { logs: snapshotSessionRunLogs((_b = (_a = input.snapshotLogs) === null || _a === void 0 ? void 0 : _a.call(input)) !== null && _b !== void 0 ? _b : []) }));
+                    }
+                    catch (_c) {
+                        // Soft-fail: a store outage must not change the HTTP reply.
+                    }
+                });
+                // Claim the file before the turn runs. The host reads it after its
+                // own POST returns, which for a 9-minute timeout is while this turn
+                // is still going; without this marker that read would surface the
+                // PREVIOUS delivery's terminal record as if it were this one's.
+                yield writeDiag({
+                    sessionId: "",
+                    turnStatus: HOSTED_EXECUTION_DIAG_RUNNING_STATUS,
+                });
+                try {
+                    const args = input.buildHandlerArgs(admitted.send.channelId, execution.sessionPublicId);
+                    const session = yield args.send(admitted.send.message, Object.assign(Object.assign({}, admitted.send.options), { mailboxContinuation: {
+                            key: admitted.send.mailboxContinuationKey,
+                        } }));
+                    const outcome = yield session.waitForCompletion();
+                    // Failed turns drain too: their record/continuation updates must
+                    // survive the park just like a finished turn's.
+                    yield (_a = input.drainSessionDurability) === null || _a === void 0 ? void 0 : _a.call(input, session.id);
+                    yield writeDiag({
+                        sessionId: session.id,
+                        turnStatus: outcome.status,
+                        message: outcome.errorMessage,
+                        abortReason: abortReasonFromTurnStatus(outcome.status, outcome.errorMessage),
+                    });
+                    if (outcome.status !== "finished") {
+                        return {
+                            status: 503,
+                            body: {
+                                ok: false,
+                                error: "turn_failed",
+                                turnStatus: outcome.status,
+                                message: outcome.errorMessage,
+                            },
+                        };
+                    }
                     return {
-                        status: 503,
+                        status: 200,
                         body: {
-                            ok: false,
-                            error: "turn_failed",
-                            turnStatus: outcome.status,
-                            message: outcome.errorMessage,
+                            ok: true,
+                            v: HOSTED_DELIVERY_PROTOCOL_VERSION,
+                            outcome: "send",
                         },
                     };
                 }
-                return {
-                    status: 200,
-                    body: {
-                        ok: true,
-                        v: HOSTED_DELIVERY_PROTOCOL_VERSION,
-                        outcome: "send",
-                    },
-                };
+                catch (error) {
+                    yield writeDiag({
+                        sessionId: "",
+                        turnStatus: "error",
+                        message: error instanceof Error ? error.message : String(error),
+                        abortReason: "execute_throw",
+                        error,
+                    });
+                    throw error;
+                }
             }))());
             const reply = yield admitted.execution;
             return finish(Response.json(reply.body, { status: reply.status }));

package/dist/internal/hosted-execution-diag.d.ts

@@ -0,0 +1,59 @@
+export declare const HOSTED_EXECUTION_DIAG_VERSION = 1;
+/** Cap so a runaway message cannot fill the guest disk or the host log. */
+export declare const HOSTED_EXECUTION_DIAG_MAX_BYTES = 4096;
+/**
+ * Correlate the on-disk record with the execution that produced it. One pod
+ * serves many deliveries of a continuation session, and the file lives at a
+ * single fixed path, so without this the host can read a *previous*
+ * delivery's terminal record whenever July never reaches its own write —
+ * the 9-minute host POST timeout, a 409 on an expired admission token, or a
+ * replayed token that short-circuits on the memoized reply.
+ *
+ * Derived from the admission token (which both sides already hold) rather
+ * than carried on the wire. The digest is one-way, so the token itself never
+ * reaches the guest disk or the host logs.
+ */
+export declare function hostedExecutionDiagId(admissionToken: string): string;
+export type HostedExecutionDiagAbortReason = "signal_abort" | "runner_cancelled" | "runner_error" | "execute_throw";
+/**
+ * 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.
+ */
+export type HostedExecutionDiag = {
+    v: typeof HOSTED_EXECUTION_DIAG_VERSION;
+    /** {@link hostedExecutionDiagId} of the execution that wrote this record. */
+    executionId: string;
+    writtenAt: string;
+    sessionPublicId: string;
+    sessionId: string;
+    /** Terminal {@link TurnOutcome} status, or `running` before the turn ends. */
+    turnStatus: string;
+    durationMs: number;
+    message?: string;
+    /** First frames of a thrown Error; omitted on soft turn failures. */
+    stack?: string;
+    signalAborted?: boolean;
+    requestId?: string;
+    abortReason?: HostedExecutionDiagAbortReason;
+};
+/** Written before the turn starts so a stalled execution still has a record. */
+export declare const HOSTED_EXECUTION_DIAG_RUNNING_STATUS = "running";
+/** First line + frames; factory `last_error` is 1024 chars with a TAS prefix. */
+export declare const HOSTED_ERROR_STACK_LINE_COUNT = 5;
+export declare 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.
+ */
+export declare function hostedErrorStackSnippet(error: unknown): string;
+export declare function hostedExecutionDiagPath(stateRoot: string): string;
+export declare function abortReasonFromTurnStatus(status: string, message: string | undefined): HostedExecutionDiagAbortReason | undefined;
+export declare function parseHostedExecutionDiag(raw: string): HostedExecutionDiag | undefined;
+/**
+ * Overwrite the per-execution diag file. Soft-fail: a write error must not
+ * change the hosted-execution HTTP reply.
+ */
+export declare function writeHostedExecutionDiag(stateRoot: string, diag: HostedExecutionDiag): Promise<void>;
+//# sourceMappingURL=hosted-execution-diag.d.ts.map

package/dist/internal/hosted-execution-diag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hosted-execution-diag.d.ts","sourceRoot":"","sources":["../../src/internal/hosted-execution-diag.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,6BAA6B,IAAI,CAAC;AAC/C,2EAA2E;AAC3E,eAAO,MAAM,+BAA+B,OAAO,CAAC;AAEpD;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAEpE;AAED,MAAM,MAAM,8BAA8B,GACtC,cAAc,GACd,kBAAkB,GAClB,cAAc,GACd,eAAe,CAAC;AAEpB;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,CAAC,EAAE,OAAO,6BAA6B,CAAC;IACxC,6EAA6E;IAC7E,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,8EAA8E;IAC9E,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qEAAqE;IACrE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,8BAA8B,CAAC;CAC9C,CAAC;AAEF,gFAAgF;AAChF,eAAO,MAAM,oCAAoC,YAAY,CAAC;AAmC9D,iFAAiF;AACjF,eAAO,MAAM,6BAA6B,IAAI,CAAC;AAC/C,eAAO,MAAM,8BAA8B,MAAM,CAAC;AAElD;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAyB9D;AAED,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEjE;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,GAAG,SAAS,GAC1B,8BAA8B,GAAG,SAAS,CAU5C;AAED,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,MAAM,GACV,mBAAmB,GAAG,SAAS,CA2EjC;AAED;;;GAGG;AACH,wBAAsB,wBAAwB,CAC5C,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,mBAAmB,GACxB,OAAO,CAAC,IAAI,CAAC,CAmBf"}

package/dist/internal/hosted-execution-diag.js

@@ -0,0 +1,187 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { createHash, randomBytes } from "node:crypto";
+import { mkdir, rename, unlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { HOSTED_EXECUTION_DIAG_FILENAME } from "./hosted-delivery-protocol.js";
+export const HOSTED_EXECUTION_DIAG_VERSION = 1;
+/** Cap so a runaway message cannot fill the guest disk or the host log. */
+export const HOSTED_EXECUTION_DIAG_MAX_BYTES = 4096;
+/**
+ * Correlate the on-disk record with the execution that produced it. One pod
+ * serves many deliveries of a continuation session, and the file lives at a
+ * single fixed path, so without this the host can read a *previous*
+ * delivery's terminal record whenever July never reaches its own write —
+ * the 9-minute host POST timeout, a 409 on an expired admission token, or a
+ * replayed token that short-circuits on the memoized reply.
+ *
+ * Derived from the admission token (which both sides already hold) rather
+ * than carried on the wire. The digest is one-way, so the token itself never
+ * reaches the guest disk or the host logs.
+ */
+export function hostedExecutionDiagId(admissionToken) {
+    return createHash("sha256").update(admissionToken).digest("hex").slice(0, 16);
+}
+/** Written before the turn starts so a stalled execution still has a record. */
+export const HOSTED_EXECUTION_DIAG_RUNNING_STATUS = "running";
+const DIAG_KEYS = new Set([
+    "v",
+    "executionId",
+    "writtenAt",
+    "sessionPublicId",
+    "sessionId",
+    "turnStatus",
+    "durationMs",
+    "message",
+    "stack",
+    "signalAborted",
+    "requestId",
+    "abortReason",
+]);
+const ABORT_REASONS = new Set([
+    "signal_abort",
+    "runner_cancelled",
+    "runner_error",
+    "execute_throw",
+]);
+function boundedOptionalString(value, max) {
+    return typeof value === "string" && value.length > 0
+        ? value.length > max
+            ? `${value.slice(0, max)}…`
+            : value
+        : undefined;
+}
+/** First line + frames; factory `last_error` is 1024 chars with a TAS prefix. */
+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.
+ */
+export function hostedErrorStackSnippet(error) {
+    var _a;
+    if (error instanceof Error) {
+        const stack = (_a = error.stack) === null || _a === void 0 ? void 0 : _a.trim();
+        if (stack !== undefined && stack.length > 0) {
+            const lines = stack
+                .split("\n")
+                .map((line) => line.trimEnd())
+                .filter((line) => line.trim().length > 0)
+                .slice(0, HOSTED_ERROR_STACK_LINE_COUNT);
+            const text = lines.join("\n");
+            return text.length > HOSTED_ERROR_SNIPPET_MAX_CHARS
+                ? `${text.slice(0, HOSTED_ERROR_SNIPPET_MAX_CHARS)}…`
+                : text;
+        }
+        return error.message.length > HOSTED_ERROR_SNIPPET_MAX_CHARS
+            ? `${error.message.slice(0, HOSTED_ERROR_SNIPPET_MAX_CHARS)}…`
+            : error.message;
+    }
+    const text = String(error);
+    if (text.length === 0) {
+        return "";
+    }
+    return text.length > HOSTED_ERROR_SNIPPET_MAX_CHARS
+        ? `${text.slice(0, HOSTED_ERROR_SNIPPET_MAX_CHARS)}…`
+        : text;
+}
+export function hostedExecutionDiagPath(stateRoot) {
+    return join(stateRoot, HOSTED_EXECUTION_DIAG_FILENAME);
+}
+export function abortReasonFromTurnStatus(status, message) {
+    if (status === "finished") {
+        return undefined;
+    }
+    if (status === "cancelled") {
+        return message !== undefined && /abort/i.test(message)
+            ? "signal_abort"
+            : "runner_cancelled";
+    }
+    return "runner_error";
+}
+export function parseHostedExecutionDiag(raw) {
+    if (raw.length === 0 || raw.length > HOSTED_EXECUTION_DIAG_MAX_BYTES) {
+        return undefined;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (_a) {
+        return undefined;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        return undefined;
+    }
+    const body = parsed;
+    if (Object.keys(body).some((key) => !DIAG_KEYS.has(key))) {
+        return undefined;
+    }
+    if (body.v !== HOSTED_EXECUTION_DIAG_VERSION ||
+        typeof body.executionId !== "string" ||
+        body.executionId.length === 0 ||
+        body.executionId.length > 64 ||
+        typeof body.writtenAt !== "string" ||
+        body.writtenAt.length === 0 ||
+        body.writtenAt.length > 64 ||
+        typeof body.sessionPublicId !== "string" ||
+        body.sessionPublicId.length === 0 ||
+        body.sessionPublicId.length > 128 ||
+        typeof body.sessionId !== "string" ||
+        body.sessionId.length > 128 ||
+        typeof body.turnStatus !== "string" ||
+        body.turnStatus.length === 0 ||
+        body.turnStatus.length > 64 ||
+        typeof body.durationMs !== "number" ||
+        !Number.isFinite(body.durationMs) ||
+        body.durationMs < 0) {
+        return undefined;
+    }
+    const message = boundedOptionalString(body.message, 1024);
+    const stack = boundedOptionalString(body.stack, HOSTED_ERROR_SNIPPET_MAX_CHARS);
+    const requestId = boundedOptionalString(body.requestId, 128);
+    const abortReason = body.abortReason === undefined
+        ? undefined
+        : typeof body.abortReason === "string" &&
+            ABORT_REASONS.has(body.abortReason)
+            ? body.abortReason
+            : undefined;
+    if (body.abortReason !== undefined && abortReason === undefined) {
+        return undefined;
+    }
+    if (body.signalAborted !== undefined &&
+        typeof body.signalAborted !== "boolean") {
+        return undefined;
+    }
+    return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ v: HOSTED_EXECUTION_DIAG_VERSION, executionId: body.executionId, writtenAt: body.writtenAt, sessionPublicId: body.sessionPublicId, sessionId: body.sessionId, turnStatus: body.turnStatus, durationMs: body.durationMs }, (message === undefined ? {} : { message })), (stack === undefined ? {} : { stack })), (body.signalAborted === true ? { signalAborted: true } : {})), (requestId === undefined ? {} : { requestId })), (abortReason === undefined ? {} : { abortReason }));
+}
+/**
+ * Overwrite the per-execution diag file. Soft-fail: a write error must not
+ * change the hosted-execution HTTP reply.
+ */
+export function writeHostedExecutionDiag(stateRoot, diag) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const path = hostedExecutionDiagPath(stateRoot);
+        const tmp = `${path}.${randomBytes(8).toString("hex")}.tmp`;
+        try {
+            yield mkdir(stateRoot, { recursive: true });
+            const serialized = JSON.stringify(diag);
+            const body = serialized.length > HOSTED_EXECUTION_DIAG_MAX_BYTES
+                ? JSON.stringify(Object.assign(Object.assign({}, diag), { stack: undefined, message: boundedOptionalString(diag.message, 256) }))
+                : serialized;
+            yield writeFile(tmp, body, "utf8");
+            yield rename(tmp, path);
+        }
+        catch (_a) {
+            yield unlink(tmp).catch(() => undefined);
+        }
+    });
+}

package/dist/internal/http-channel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http-channel.d.ts","sourceRoot":"","sources":["../../src/internal/http-channel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAEV,WAAW,EACX,UAAU,EACV,qBAAqB,EACrB,aAAa,EACd,MAAM,aAAa,CAAC;AAIrB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAKL,KAAK,aAAa,EACnB,MAAM,qBAAqB,CAAC;AAQ7B,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,MAAM,EAAE,aAAa,CAAC;IACtB,MAAM,EAAE,qBAAqB,CAAC;IAC9B,IAAI,EAAE,UAAU,EAAE,CAAC;IACnB,4DAA4D;IAC5D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;;OAMG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B;;;OAGG;IACH,kCAAkC,CAAC,EAAE,OAAO,CAAC;IAC7C;;;;;OAKG;IACH,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACpC,GAAG,WAAW,EAAE,CAkZhB;AAED,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,WAAW,GAAG,IAAI,EAC1B,OAAO,CAAC,EAAE;IACR,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B,GACA,QAAQ,GAAG,SAAS,CAiBtB;AAED,wBAAgB,YAAY,CAC1B,IAAI,EAAE,OAAO,EACb,IAAI,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAO,GAC/D,QAAQ,CAQV;AAED,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd,QAAQ,CAEV;AAoGD,wBAAsB,cAAc,CAClC,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC,CAc9C"}
+{"version":3,"file":"http-channel.d.ts","sourceRoot":"","sources":["../../src/internal/http-channel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAEV,WAAW,EACX,UAAU,EACV,qBAAqB,EACrB,aAAa,EACd,MAAM,aAAa,CAAC;AAIrB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAOL,KAAK,aAAa,EACnB,MAAM,qBAAqB,CAAC;AAQ7B,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,MAAM,EAAE,aAAa,CAAC;IACtB,MAAM,EAAE,qBAAqB,CAAC;IAC9B,IAAI,EAAE,UAAU,EAAE,CAAC;IACnB,4DAA4D;IAC5D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;;OAMG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B;;;OAGG;IACH,kCAAkC,CAAC,EAAE,OAAO,CAAC;IAC7C;;;;;OAKG;IACH,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACpC,GAAG,WAAW,EAAE,CA2fhB;AAED,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,WAAW,GAAG,IAAI,EAC1B,OAAO,CAAC,EAAE;IACR,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B,GACA,QAAQ,GAAG,SAAS,CAiBtB;AAED,wBAAgB,YAAY,CAC1B,IAAI,EAAE,OAAO,EACb,IAAI,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAO,GAC/D,QAAQ,CAQV;AAED,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd,QAAQ,CAEV;AAoGD,wBAAsB,cAAc,CAClC,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC,CAc9C"}

package/dist/internal/http-channel.js

@@ -22,7 +22,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { samePrincipal } from "./auth.js";
 import { formatContinuationToken, parseContinuationToken } from "./ids.js";
 import { isLoopbackAddress } from "./net.js";
-import { ApprovalInterruptedError, ApprovalNotFoundError, HTTP_CHANNEL_ID, SessionAuthError, } from "./session-engine.js";
+import { ApprovalInterruptedError, ApprovalNotFoundError, AuthInterruptedError, AuthNotFoundError, HTTP_CHANNEL_ID, SessionAuthError, } from "./session-engine.js";
 import { eventsUrlForSession, playgroundUrlForSession, } from "./session-urls.js";
 const SESSION_ID_HEADER = "x-agent-serve-session-id";
 export function buildHttpChannelRoutes(args) {
@@ -48,12 +48,15 @@ export function buildHttpChannelRoutes(args) {
             if (body === undefined || typeof body.message !== "string") {
                 return errorResponse(400, "invalid_request", "Expected a JSON body with a string `message`.");
             }
+            if (body.asOf !== undefined && typeof body.asOf !== "string") {
+                return errorResponse(400, "invalid_request", "`asOf` must be an ISO-8601 instant with a timezone when provided.");
+            }
             const message = yield transformMessage(body.message, ctx.auth);
             const workspaceFiles = readWorkspaceFiles(body.workspaceFiles);
             // Per-session cloud attach (create only). Eval harness uses this to pin
             // fixture repos without putting them on the agent's default cloud.repos.
             const cloud = readCloudOptions(body.cloud);
-            const session = yield engine.send(HTTP_CHANNEL_ID, message, Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ auth: ctx.auth }, (typeof body.title === "string" ? { title: body.title } : {})), (body.purpose === "eval" ? { purpose: "eval" } : {})), (body.dryRun === true ? { dryRun: true } : {})), (workspaceFiles === undefined ? {} : { workspaceFiles })), (cloud === undefined ? {} : { cloud })));
+            const session = yield engine.send(HTTP_CHANNEL_ID, message, Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ auth: ctx.auth }, (typeof body.title === "string" ? { title: body.title } : {})), (body.purpose === "eval" ? { purpose: "eval" } : {})), (body.dryRun === true ? { dryRun: true } : {})), { asOf: body.asOf }), (workspaceFiles === undefined ? {} : { workspaceFiles })), (cloud === undefined ? {} : { cloud })));
             return jsonResponse({
                 ok: true,
                 sessionId: session.id,
@@ -324,6 +327,84 @@ export function buildHttpChannelRoutes(args) {
             return jsonResponse({ ok: true, interrupted }, { headers: { [SESSION_ID_HEADER]: sessionId } });
         }),
     };
+    const listAuths = {
+        method: "GET",
+        pattern: `${base}/v1/session/:sessionId/auths`,
+        auth,
+        handler: (_request, ctx) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const sessionId = (_a = ctx.params.sessionId) !== null && _a !== void 0 ? _a : "";
+            const record = yield engine.getOrRestoreSession(sessionId);
+            if (record === undefined) {
+                return errorResponse(404, "session_not_found", `Unknown session ${sessionId}.`);
+            }
+            const ownership = requireSessionOwner(record, ctx.auth, {
+                relax: relaxSessionReadAuth,
+                beyondLoopback: relaxSessionReadAuthBeyondLoopback,
+                requestIp: ctx.requestIp,
+            });
+            if (ownership !== undefined) {
+                return ownership;
+            }
+            const pending = yield engine.listPendingAuths(sessionId);
+            return jsonResponse({ ok: true, sessionId, pending });
+        }),
+    };
+    const resolveAuth = {
+        method: "POST",
+        pattern: `${base}/v1/session/:sessionId/auths/:callId`,
+        auth,
+        handler: (request, ctx) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            var _b, _c;
+            const sessionId = (_b = ctx.params.sessionId) !== null && _b !== void 0 ? _b : "";
+            const callId = (_c = ctx.params.callId) !== null && _c !== void 0 ? _c : "";
+            const record = yield engine.getOrRestoreSession(sessionId);
+            if (record === undefined) {
+                return errorResponse(404, "session_not_found", `Unknown session ${sessionId}.`);
+            }
+            const bridgeSlackAuth = relaxSessionApprovalAuth === true &&
+                ((_a = record.auth) === null || _a === void 0 ? void 0 : _a.authenticator) === "slack" &&
+                (relaxSessionReadAuthBeyondLoopback === true ||
+                    (typeof ctx.requestIp === "string" &&
+                        isLoopbackAddress(ctx.requestIp)));
+            const ownership = requireSessionOwner(record, ctx.auth, {
+                relax: bridgeSlackAuth,
+                beyondLoopback: relaxSessionReadAuthBeyondLoopback,
+                requestIp: ctx.requestIp,
+            });
+            if (ownership !== undefined) {
+                return ownership;
+            }
+            const body = yield readJsonObject(request);
+            const decision = body === null || body === void 0 ? void 0 : body.decision;
+            if (decision !== "approve" && decision !== "deny") {
+                return errorResponse(400, "invalid_request", 'Expected a JSON body with `decision`: "approve" | "deny".');
+            }
+            try {
+                const pending = yield engine.resolveAuth(sessionId, callId, decision, ctx.auth, bridgeSlackAuth ? { asSessionOwner: true } : undefined);
+                return jsonResponse({
+                    ok: true,
+                    sessionId,
+                    callId,
+                    decision,
+                    connection: pending.connection,
+                });
+            }
+            catch (error) {
+                if (error instanceof AuthNotFoundError) {
+                    return errorResponse(404, "auth_not_found", error.message);
+                }
+                if (error instanceof AuthInterruptedError) {
+                    return errorResponse(409, "auth_interrupted", error.message);
+                }
+                if (error instanceof SessionAuthError) {
+                    return errorResponse(403, "forbidden", error.message);
+                }
+                throw error;
+            }
+        }),
+    };
     return [
         createSession,
         followUp,
@@ -333,6 +414,8 @@ export function buildHttpChannelRoutes(args) {
         cost,
         listApprovals,
         resolveApproval,
+        listAuths,
+        resolveAuth,
     ];
 }
 export function requireSessionOwner(record, caller, options) {