@aexhq/sdk 0.32.0 → 0.33.1

package/README.md

@@ -8,7 +8,8 @@ aex is an agent execution platform for launching autonomous agents from a simple
 
 The package ships:
 
-- `AgentExecutor` for submit, run, wait, stream, inspect, download, cancel, and delete.
+- `Aex` / `AgentExecutor` for sessions, one-shot runs, inspect, download, cancel, and delete.
+- `sessions` / `openSession()` for durable, resumable agent sessions.
 - Typed run primitives: `Models`, `Providers`, `RuntimeSizes`, `Skill`, `AgentsMd`, `File`, `McpServer`, `ProxyEndpoint`, and `Secret`.
 - A bundled `aex` CLI with the same run, status, events, outputs, download, cancel, delete, whoami, and skills operations.
 
@@ -27,56 +28,53 @@ export AEX_API_TOKEN="<your-aex-token>"
 export ANTHROPIC_API_KEY="<your-anthropic-api-key>"
 ```
 
-## First Run
+## First Session
 
 ```ts
-import { AgentExecutor, Models } from "@aexhq/sdk";
+import { Aex, Models, Sizes } from "@aexhq/sdk";
 
-const aex = new AgentExecutor({ apiToken: process.env.AEX_API_TOKEN! });
+const aex = new Aex({ apiToken: process.env.AEX_API_TOKEN! });
 
-// run() submits, waits for the run to settle, and returns the result —
-// no manual poll loop. `provider` is derived from the model.
-const { text, ok } = await aex.run({
+const session = await aex.openSession({
   model: Models.CLAUDE_HAIKU_4_5,
-  secrets: { apiKeys: { anthropic: process.env.ANTHROPIC_API_KEY! } },
-  prompt: "Summarize this repo."
+  system: "You are a concise engineering assistant.",
+  runtime: Sizes.SHARED_0_25X_1GB,
+  // Default is "3m"; set it explicitly when you want a different idle window.
+  overrides: { idleTtl: "3m" },
+  apiKeys: { anthropic: process.env.ANTHROPIC_API_KEY! }
 });
 
-console.log(ok, text);
+const first = await session.send("Summarize this repo.").done();
+console.log(first.status, first.text);
+
+const resumed = await aex.openSession(session.id);
+await resumed.send("Continue with the follow-up validation.").done();
 ```
 
-Need the run id, live events, or downloads? Use `submit` + `stream` + `wait`:
+Need a one-shot convenience? `run()` opens a session, sends `message` as one
+turn, and returns the collected result. The returned `runId` is the session id,
+so it can be resumed later with `openSession(runId)`.
 
 ```ts
-const runId = await aex.submit({
+const result = await aex.run({
   model: Models.CLAUDE_HAIKU_4_5,
-  secrets: { apiKeys: { anthropic: process.env.ANTHROPIC_API_KEY! } },
-  prompt: "Write the report and save outputs."
+  apiKeys: { anthropic: process.env.ANTHROPIC_API_KEY! },
+  message: "Write the report and save outputs."
 });
 
-for await (const event of aex.stream(runId)) {
-  console.log(event.type);
-}
-
-const run = await aex.wait(runId);
-console.log(run.status);
-
-await aex.download(runId, { to: "./run.zip" });
+console.log(result.runId, result.status, result.text);
 ```
 
-For multiple providers (e.g. subagents on a different model family), include
-each BYOK key in `secrets.apiKeys`:
+For multiple providers, include each BYOK key in `apiKeys`:
 
 ```ts
 await aex.run({
   model: Models.CLAUDE_HAIKU_4_5,
-  secrets: {
-    apiKeys: {
-      anthropic: process.env.ANTHROPIC_API_KEY!,
-      openai: process.env.OPENAI_API_KEY!
-    }
+  apiKeys: {
+    anthropic: process.env.ANTHROPIC_API_KEY!,
+    openai: process.env.OPENAI_API_KEY!
   },
-  prompt: "Delegate research to a subagent."
+  message: "Delegate research to a subagent."
 });
 ```
 
@@ -144,7 +142,7 @@ finds output files across runs and returns references (no bytes) you then
 
 ## Feature Areas
 
-- **Agent runtime:** managed autonomous runs with filesystem read/edit, grep/glob/head/tail, open web fetch/search defaults, optional notebook tools, and post-hook repair.
+- **Agent runtime:** managed autonomous runs with filesystem read/edit, grep/glob/head/tail, open web fetch/search defaults, and optional notebook tools.
 - **Durable infrastructure:** run records, status, wait/cancel/delete, idempotency, typed events, output capture, downloads, timeouts, and runtime sizes.
 - **Agent composition:** skills, files, AGENTS.md, remote MCP servers, proxy endpoints, environment variables, packages, and networking controls.
 - **Subagents:** typed parent/child lineage for async child runs, output handoff, and bounded agent delegation.

package/dist/_contracts/event-stream-client.d.ts

@@ -12,7 +12,7 @@
  * A silently half-open socket (no close/error, no frames) is the dangerous
  * case: the read loop would block forever and MISS a terminal that was already
  * persisted server-side. So the client sends a tiny keep-alive ping the
- * coordinator auto-responds to (hibernation-safe, no DO wake) and runs an idle
+ * coordinator answers with a matching pong, and runs an idle
  * watchdog: if no frame arrives within {@link CoordinatorStreamOptions.idleTimeoutMs},
  * the socket is treated as dead and reconnected — resume-from-cursor then
  * replays the terminal.
@@ -65,7 +65,7 @@ export interface CoordinatorStreamOptions {
     readonly idleTimeoutMs?: number;
     /**
      * Client keep-alive ping cadence. The client sends {@link COORDINATOR_PING},
-     * which the coordinator auto-responds to WITHOUT waking the stateful coordinator, so
+     * which the coordinator answers with a matching pong, so
      * a legitimately quiet run keeps the socket measurably alive and does not trip
      * the watchdog. Default 15s. Set 0 to disable (then only real events reset the
      * watchdog → quiet runs may reconnect).

package/dist/_contracts/event-stream-client.js

@@ -12,7 +12,7 @@
  * A silently half-open socket (no close/error, no frames) is the dangerous
  * case: the read loop would block forever and MISS a terminal that was already
  * persisted server-side. So the client sends a tiny keep-alive ping the
- * coordinator auto-responds to (hibernation-safe, no DO wake) and runs an idle
+ * coordinator answers with a matching pong, and runs an idle
  * watchdog: if no frame arrives within {@link CoordinatorStreamOptions.idleTimeoutMs},
  * the socket is treated as dead and reconnected — resume-from-cursor then
  * replays the terminal.
@@ -26,8 +26,8 @@
  */
 const isTerminalType = (e) => e.type === "RUN_FINISHED" || e.type === "RUN_ERROR";
 /**
- * Keep-alive ping the client sends; the coordinator answers it via
- * `setWebSocketAutoResponse` without waking the DO. Must stay byte-identical to
+ * Keep-alive ping the client sends; the coordinator answers it with the matching
+ * pong in its WebSocket message handler. Must stay byte-identical to
  * the coordinator's pair (aex-platform `packages/shared/src/event-stream-client.ts`).
  */
 const COORDINATOR_PING = "aex:ping";

package/dist/_contracts/index.d.ts

@@ -4,7 +4,6 @@ export * from "./models.js";
 export * from "./status.js";
 export * from "./submission.js";
 export * from "./runtime-sizes.js";
-export * from "./post-hook.js";
 export * from "./runner-event.js";
 export * from "./event-envelope.js";
 export * from "./connection-ticket.js";

package/dist/_contracts/index.js

@@ -4,7 +4,6 @@ export * from "./models.js";
 export * from "./status.js";
 export * from "./submission.js";
 export * from "./runtime-sizes.js";
-export * from "./post-hook.js";
 export * from "./runner-event.js";
 export * from "./event-envelope.js";
 export * from "./connection-ticket.js";

package/dist/_contracts/operations.d.ts

@@ -1,6 +1,6 @@
 import type { HttpClient } from "./http.js";
 import type { RunUnit } from "./run-unit.js";
-import type { AgentsMdRecord, FileRecord, Output, OutputLink, OutputLinkOptions, OutputFileDownload, OutputFileSelector, OutputFileType, OutputQuery, OutputText, ReadOutputTextOptions, Run, RunEvent, RunListPage, RunListQuery, RunWebhookDelivery, SecretRecord, SecretReveal, Skill, WhoAmI } from "./runtime-types.js";
+import type { AgentsMdRecord, FileRecord, Output, OutputLink, OutputLinkOptions, OutputFileDownload, OutputFileSelector, OutputFileType, OutputQuery, OutputText, ReadOutputTextOptions, Run, RunEvent, RunListPage, RunListQuery, Session, SessionCreateRequest, SessionEvent, SessionListPage, SessionListQuery, SessionMessageAccepted, SessionMessageRequest, SessionStateChangeAccepted, RunWebhookDelivery, SecretRecord, SecretReveal, Skill, WhoAmI } from "./runtime-types.js";
 import type { PlatformRunSubmissionInput } from "./submission.js";
 /**
  * The single source of truth for SDK<->BFF transport. The SDK class
@@ -37,6 +37,20 @@ export declare function getRunUnit(http: HttpClient, runId: string): Promise<Run
  * For a single page; callers wanting every run loop on `nextCursor` themselves.
  */
 export declare function listRuns(http: HttpClient, query?: RunListQuery): Promise<RunListPage>;
+export interface IdempotencyOptions {
+    readonly idempotencyKey?: string;
+}
+export declare function createSession(http: HttpClient, request: SessionCreateRequest, options?: IdempotencyOptions): Promise<Session>;
+export declare function getSession(http: HttpClient, sessionId: string): Promise<Session>;
+export declare function listSessions(http: HttpClient, query?: SessionListQuery): Promise<SessionListPage>;
+export declare function sendSessionMessage(http: HttpClient, sessionId: string, request: SessionMessageRequest, options?: IdempotencyOptions): Promise<SessionMessageAccepted>;
+export declare function suspendSession(http: HttpClient, sessionId: string, options?: IdempotencyOptions): Promise<SessionStateChangeAccepted>;
+export declare function cancelSession(http: HttpClient, sessionId: string, options?: IdempotencyOptions): Promise<SessionStateChangeAccepted>;
+export declare function resumeSession(http: HttpClient, sessionId: string, options?: IdempotencyOptions): Promise<SessionStateChangeAccepted>;
+export declare function deleteSession(http: HttpClient, sessionId: string, options?: IdempotencyOptions): Promise<SessionStateChangeAccepted | void>;
+export declare function listSessionEvents(http: HttpClient, sessionId: string): Promise<readonly SessionEvent[]>;
+export declare function listSessionOutputs(http: HttpClient, sessionId: string, query?: OutputQuery): Promise<readonly Output[]>;
+export declare function getSessionCoordinatorTicket(http: HttpClient, sessionId: string): Promise<CoordinatorTicket>;
 /**
  * List a run's events. The read endpoint is PAGED (bounded per response so a
  * long run can't return an unbounded body); this follows `nextCursor` across

package/dist/_contracts/operations.js

@@ -52,6 +52,79 @@ export async function listRuns(http, query) {
         params.cursor = query.cursor;
     return http.request("/api/runs", {}, params);
 }
+function idempotencyHeaders(options) {
+    return options?.idempotencyKey ? { "Idempotency-Key": options.idempotencyKey } : undefined;
+}
+export async function createSession(http, request, options) {
+    const headers = idempotencyHeaders(options);
+    const result = await http.request("/api/sessions", {
+        method: "POST",
+        ...(headers ? { headers } : {}),
+        body: JSON.stringify(request)
+    });
+    return unwrapSession(result);
+}
+export async function getSession(http, sessionId) {
+    const result = await http.request(`/api/sessions/${encodeURIComponent(sessionId)}`);
+    return unwrapSession(result);
+}
+export async function listSessions(http, query) {
+    const params = {};
+    if (query?.status !== undefined)
+        params.status = query.status;
+    if (query?.since !== undefined)
+        params.since = query.since;
+    if (query?.limit !== undefined)
+        params.limit = String(query.limit);
+    if (query?.cursor !== undefined)
+        params.cursor = query.cursor;
+    return http.request("/api/sessions", {}, params);
+}
+export async function sendSessionMessage(http, sessionId, request, options) {
+    const headers = idempotencyHeaders(options);
+    return http.request(`/api/sessions/${encodeURIComponent(sessionId)}/messages`, {
+        method: "POST",
+        ...(headers ? { headers } : {}),
+        body: JSON.stringify(request)
+    });
+}
+export async function suspendSession(http, sessionId, options) {
+    const headers = idempotencyHeaders(options);
+    return http.request(`/api/sessions/${encodeURIComponent(sessionId)}/suspend`, { method: "POST", ...(headers ? { headers } : {}) });
+}
+export async function cancelSession(http, sessionId, options) {
+    const headers = idempotencyHeaders(options);
+    return http.request(`/api/sessions/${encodeURIComponent(sessionId)}/cancel`, { method: "POST", ...(headers ? { headers } : {}) });
+}
+export async function resumeSession(http, sessionId, options) {
+    const headers = idempotencyHeaders(options);
+    return http.request(`/api/sessions/${encodeURIComponent(sessionId)}/resume`, { method: "POST", ...(headers ? { headers } : {}) });
+}
+export async function deleteSession(http, sessionId, options) {
+    const headers = idempotencyHeaders(options);
+    return http.request(`/api/sessions/${encodeURIComponent(sessionId)}`, { method: "DELETE", ...(headers ? { headers } : {}) });
+}
+export async function listSessionEvents(http, sessionId) {
+    const path = `/api/sessions/${encodeURIComponent(sessionId)}/events`;
+    const all = [];
+    let cursor;
+    for (let page = 0; page < LIST_EVENTS_PAGE_BUDGET; page++) {
+        const query = cursor !== undefined ? { cursor: String(cursor) } : {};
+        const result = await http.request(path, {}, query);
+        all.push(...result.events);
+        if (typeof result.nextCursor !== "number")
+            break;
+        cursor = result.nextCursor;
+    }
+    return all;
+}
+export async function listSessionOutputs(http, sessionId, query) {
+    const result = await http.request(`/api/sessions/${encodeURIComponent(sessionId)}/outputs`);
+    return query === undefined ? result.outputs : filterOutputs(result.outputs, query);
+}
+export async function getSessionCoordinatorTicket(http, sessionId) {
+    return http.request(`/api/sessions/${encodeURIComponent(sessionId)}/events/ticket`, { method: "POST" });
+}
 // Bound the transparent pager: the read route caps each page at 1000, so this
 // admits up to ~1e6 events before bailing — past any real run, but bounded so a
 // server that never clears `nextCursor` can't loop forever.
@@ -815,6 +888,12 @@ function unwrapSkill(result) {
 function hasRun(value) {
     return Boolean(value && typeof value === "object" && "run" in value);
 }
+function unwrapSession(result) {
+    if (result && typeof result === "object" && "session" in result) {
+        return result.session;
+    }
+    return result;
+}
 /**
  * Upload bytes to the hosted API's content-addressable asset endpoint.
  * Returns a storage-neutral asset id suitable for `kind:"asset"` refs in a

package/dist/_contracts/post-hook.d.ts

@@ -3,9 +3,9 @@ export declare const DEFAULT_POST_HOOK_TIMEOUT_MS: number;
 /** Default number of repair turns after a failing hook. */
 export declare const DEFAULT_POST_HOOK_MAX_TURNS = 10;
 /**
- * Customer-facing post-agent-run verifier shape. The SDK and run-config JSON
- * send this form on the wire; the server parser normalizes it to
- * {@link PlatformPostHook}.
+ * Legacy/private post-agent-run verifier input. The public SDK no longer
+ * accepts this field; platform-internal paths may still normalize old wire
+ * records to {@link PlatformPostHook}.
  */
 export interface PlatformPostHookInput {
     readonly command: string;
@@ -21,7 +21,7 @@ export interface PlatformPostHook {
     readonly maxChars: number | null;
 }
 /**
- * Parse the public `postHook` option. An omitted hook, null hook, or hook with
+ * Parse the legacy/private `postHook` option. An omitted hook, null hook, or hook with
  * an empty/whitespace-only command is treated as omitted so callers can pre-fill
  * configs without enabling the verifier accidentally.
  */

package/dist/_contracts/post-hook.js

@@ -4,7 +4,7 @@ export const DEFAULT_POST_HOOK_TIMEOUT_MS = 5 * 60 * 1000;
 /** Default number of repair turns after a failing hook. */
 export const DEFAULT_POST_HOOK_MAX_TURNS = 10;
 /**
- * Parse the public `postHook` option. An omitted hook, null hook, or hook with
+ * Parse the legacy/private `postHook` option. An omitted hook, null hook, or hook with
  * an empty/whitespace-only command is treated as omitted so callers can pre-fill
  * configs without enabling the verifier accidentally.
  */

package/dist/_contracts/run-config.d.ts

@@ -31,7 +31,6 @@
 import { type JsonValue, type PlatformProxyEndpoint, type PlatformEnvironment } from "./submission.js";
 import { type RunModel } from "./models.js";
 import type { RuntimeSize } from "./runtime-sizes.js";
-import { type PlatformPostHookInput } from "./post-hook.js";
 /**
  * Mirrors the server-side CHECK constraint
  * `skill_bundles_id_format_chk = check (id ~ '^skl_[A-Za-z0-9_-]{8,128}$')`
@@ -299,8 +298,6 @@ export interface RunRequestConfig {
     readonly runtimeSize?: RuntimeSize;
     /** Run deadline as a duration string (`"1h"`, `"30m"`); bounded [1m, 6h] server-side. */
     readonly timeout?: string;
-    /** Post-agent-run verifier command. Empty command is treated as omitted. */
-    readonly postHook?: PlatformPostHookInput;
     readonly proxyEndpoints?: readonly PlatformProxyEndpoint[];
     readonly metadata?: Readonly<Record<string, JsonValue>>;
 }
@@ -330,7 +327,6 @@ export interface NormalisedRunRequestConfig {
     readonly environment?: PlatformEnvironment;
     readonly proxyEndpoints?: readonly PlatformProxyEndpoint[];
     readonly metadata?: Readonly<Record<string, JsonValue>>;
-    readonly postHook?: PlatformPostHookInput;
     /**
      * MCP servers whose run-config entry carried `headers`. Keyed by the `name`
      * that appears in `mcpServers` so the BFF can pair them up.

package/dist/_contracts/run-config.js

@@ -29,7 +29,6 @@
  * boundary.
  */
 import { parseRunModel } from "./models.js";
-import { parsePostHook } from "./post-hook.js";
 // ---------------------------------------------------------------------------
 // Skill ID + name format
 // ---------------------------------------------------------------------------
@@ -617,7 +616,6 @@ export function parseRunRequestConfig(input) {
         "environment",
         "runtimeSize",
         "timeout",
-        "postHook",
         "proxyEndpoints",
         "metadata"
     ]);
@@ -634,7 +632,6 @@ export function parseRunRequestConfig(input) {
     const prompt = parseRunRequestConfigPrompt(record.prompt);
     const skills = parseRunRequestConfigSkills(record.skills);
     const mcpServers = parseRunRequestConfigMcpServers(record.mcpServers);
-    const postHook = parsePostHook(record.postHook, "run request config postHook");
     return {
         model,
         ...(system !== undefined ? { system } : {}),
@@ -654,9 +651,6 @@ export function parseRunRequestConfig(input) {
         ...(record.timeout !== undefined
             ? { timeout: record.timeout }
             : {}),
-        ...(postHook !== undefined
-            ? { postHook: record.postHook }
-            : {}),
         ...(record.proxyEndpoints !== undefined
             ? { proxyEndpoints: record.proxyEndpoints }
             : {}),
@@ -734,7 +728,6 @@ export function normaliseRunRequestConfig(config) {
         ...(config.environment !== undefined ? { environment: config.environment } : {}),
         ...(config.proxyEndpoints !== undefined ? { proxyEndpoints: config.proxyEndpoints } : {}),
         ...(config.metadata !== undefined ? { metadata: config.metadata } : {}),
-        ...(config.postHook !== undefined ? { postHook: config.postHook } : {}),
         mcpServerSecrets
     };
 }

package/dist/_contracts/runtime-types.d.ts

@@ -1,3 +1,5 @@
+import type { SessionStatus } from "./status.js";
+import type { PlatformRunSubmissionInput, PlatformSubmission } from "./submission.js";
 /**
  * Loose record describing a run as the dashboard BFF returns it. Concrete
  * dashboard-managed fields appear in the index signature; the SDK and CLI
@@ -38,6 +40,90 @@ export interface Run {
     readonly runtimeManifest?: import("./runtime-manifest.js").RuntimeManifest;
     readonly [key: string]: unknown;
 }
+export type SessionTurnStatus = "none" | "launching" | "running" | "parking" | "idle" | "suspended" | "failed";
+export interface SessionTurn {
+    readonly sessionId: string;
+    readonly turnSeq: number;
+    readonly turnId?: string;
+    readonly status?: SessionTurnStatus;
+    readonly startedAt?: string;
+    readonly endedAt?: string | null;
+    readonly eventCursor?: number;
+}
+export interface Session {
+    readonly id: string;
+    readonly sessionId?: string;
+    readonly status: SessionStatus | string;
+    readonly turnSeq?: number;
+    readonly turnStatus?: SessionTurnStatus;
+    /** How long the session may remain idle before it is suspended. */
+    readonly idleTtl?: string;
+    readonly idleTtlMs?: number;
+    readonly createdAt?: string;
+    readonly updatedAt?: string;
+    readonly idleAt?: string | null;
+    readonly suspendedAt?: string | null;
+    readonly activeDurationMs?: number;
+    readonly lastTurnDurationMs?: number;
+    readonly retainedStorageBytes?: number;
+    readonly usage?: UsageSummary;
+    readonly costUsd?: number;
+    readonly errorMessage?: string | null;
+    readonly [key: string]: unknown;
+}
+export interface SessionSummary {
+    readonly id: string;
+    readonly sessionId?: string;
+    readonly status: SessionStatus | string;
+    readonly turnSeq?: number;
+    /** How long the session may remain idle before it is suspended. */
+    readonly idleTtl?: string;
+    readonly idleTtlMs?: number;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly idleAt?: string | null;
+    readonly suspendedAt?: string | null;
+    readonly activeDurationMs?: number;
+    readonly retainedStorageBytes?: number;
+    readonly costUsd?: number;
+}
+export interface SessionListQuery {
+    readonly status?: string;
+    readonly since?: string;
+    readonly limit?: number;
+    readonly cursor?: string;
+}
+export interface SessionListPage {
+    readonly sessions: readonly SessionSummary[];
+    readonly nextCursor?: string;
+}
+export interface SessionRetentionPolicy {
+    /** How long the session may remain idle before it is suspended. */
+    readonly idleTtl?: string;
+}
+export type SessionSubmission = Omit<PlatformSubmission, "prompt"> & {
+    readonly prompt?: readonly string[];
+};
+export type SessionCreateRequest = Omit<PlatformRunSubmissionInput, "idempotencyKey" | "submission"> & {
+    readonly submission: SessionSubmission;
+    readonly input?: string | readonly string[];
+    readonly retention?: SessionRetentionPolicy;
+};
+export interface SessionMessageRequest {
+    readonly input: string | readonly string[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface SessionMessageAccepted {
+    readonly session: Session;
+    readonly turn: SessionTurn;
+    readonly eventCursor?: number;
+}
+export interface SessionStateChangeAccepted {
+    readonly session: Session;
+    readonly turn?: SessionTurn;
+    readonly eventCursor?: number;
+}
+export type SessionEvent = import("./event-envelope.js").AexEvent;
 export interface UsageSummary {
     readonly inputTokens?: number;
     readonly outputTokens?: number;

package/dist/_contracts/status.d.ts

@@ -1,5 +1,7 @@
-export declare const RUN_STATUSES: readonly ["queued", "claiming", "provisioning", "session_created", "dispatched", "provider_running", "provider_idle", "provider_rescheduled", "cancelling", "capturing_outputs", "cleaning_up", "succeeded", "failed", "timed_out", "cancelled", "cleanup_failed"];
+export declare const RUN_STATUSES: readonly ["queued", "claiming", "provisioning", "session_created", "dispatched", "provider_running", "provider_idle", "provider_rescheduled", "idle", "suspending", "suspended", "deleting", "deleted", "expired", "cancelling", "capturing_outputs", "cleaning_up", "succeeded", "failed", "timed_out", "cancelled", "cleanup_failed"];
 export type RunStatus = typeof RUN_STATUSES[number];
+export declare const SESSION_STATUSES: readonly ["creating", "running", "idle", "suspending", "suspended", "cancelling", "deleting", "deleted", "error"];
+export type SessionStatus = typeof SESSION_STATUSES[number];
 export type RunStatusKind = "active" | "terminal";
 export declare const TERMINAL_RUN_STATUSES: readonly ["succeeded", "failed", "timed_out", "cancelled", "cleanup_failed"];
 export declare function isTerminalRunStatus(status: RunStatus): boolean;

package/dist/_contracts/status.js

@@ -7,6 +7,12 @@ export const RUN_STATUSES = [
     "provider_running",
     "provider_idle",
     "provider_rescheduled",
+    "idle",
+    "suspending",
+    "suspended",
+    "deleting",
+    "deleted",
+    "expired",
     "cancelling",
     "capturing_outputs",
     "cleaning_up",
@@ -16,6 +22,17 @@ export const RUN_STATUSES = [
     "cancelled",
     "cleanup_failed"
 ];
+export const SESSION_STATUSES = [
+    "creating",
+    "running",
+    "idle",
+    "suspending",
+    "suspended",
+    "cancelling",
+    "deleting",
+    "deleted",
+    "error"
+];
 export const TERMINAL_RUN_STATUSES = [
     "succeeded",
     "failed",

package/dist/_contracts/submission.d.ts

@@ -2,7 +2,6 @@ import { PROXY_ENDPOINT_DEFAULTS, type ProxyAuthShape, type ProxyMethod, type Pr
 export { PROXY_ENDPOINT_DEFAULTS };
 import type { AgentsMdRef, FileRef, McpServerRef, SkillRef, ToolRef } from "./run-config.js";
 import { type RuntimeSize } from "./runtime-sizes.js";
-import { type PlatformPostHook, type PlatformPostHookInput } from "./post-hook.js";
 import { type RunModel } from "./models.js";
 import { type RuntimeSecurityProfileName } from "./runtime-security-profile.js";
 export type JsonPrimitive = string | number | boolean | null;
@@ -395,13 +394,6 @@ export interface PlatformRunSubmissionRequest {
      * terminal wait window and self-kill deadline.
      */
     readonly timeoutMs?: number;
-    /**
-     * Optional post-agent-run verifier. Parsed from the public `postHook`
-     * duration/string shape into fixed runner budgets. The runner executes it
-     * after a successful agent process and sends failures back through the model
-     * for repair until this budget is exhausted.
-     */
-    readonly postHook?: PlatformPostHook;
     /**
      * Lineage parent (agent-session §9). When present the server admits this
      * run as a CHILD of `parentRunId`: it walks the parent's lineage, enforces
@@ -466,7 +458,7 @@ export interface RunLimits {
  * {@link DEFAULT_RUN_PROVIDER} (`anthropic`). The parser fills it in
  * before the value enters the run snapshot.
  */
-export type PlatformRunSubmissionInput = Omit<PlatformRunSubmissionRequest, "workspaceId" | "provider" | "timeoutMs" | "postHook"> & {
+export type PlatformRunSubmissionInput = Omit<PlatformRunSubmissionRequest, "workspaceId" | "provider" | "timeoutMs"> & {
     readonly workspaceId?: string;
     readonly provider?: RunProvider;
     /**
@@ -475,7 +467,6 @@ export type PlatformRunSubmissionInput = Omit<PlatformRunSubmissionRequest, "wor
      * {@link PlatformRunSubmissionRequest.timeoutMs}. Absent ⇒ 1h default.
      */
     readonly timeout?: string;
-    readonly postHook?: PlatformPostHookInput;
 };
 export interface ParseRunSubmissionOptions {
 }

package/dist/_contracts/submission.js

@@ -6,7 +6,6 @@ import { authShapeHeaderName, PROXY_ALLOWED_METHODS, PROXY_ENDPOINT_DEFAULTS, PR
 export { PROXY_ENDPOINT_DEFAULTS };
 import { TOOL_NAME_PATTERN, normaliseSkillBundlePath, parseAssetRefFields, parseMcpServerRef, parseSkillRef } from "./run-config.js";
 import { parseRunTimeout, parseRuntimeSize } from "./runtime-sizes.js";
-import { parsePostHook } from "./post-hook.js";
 import { assertRunModelMatchesProvider, parseRunModel } from "./models.js";
 import { parseRuntimeSecurityProfile } from "./runtime-security-profile.js";
 /**
@@ -994,7 +993,6 @@ export function parseRunSubmissionRequest(input, options = {}) {
         "submission",
         "runtimeSize",
         "timeout",
-        "postHook",
         "proxyEndpoints",
         "parentRunId",
         "webhook",
@@ -1027,7 +1025,6 @@ export function parseRunSubmissionRequest(input, options = {}) {
     const parentRunId = optionalString(value.parentRunId, "submission.parentRunId");
     const webhook = parseRunWebhook(value.webhook);
     const limits = parseRunLimits(value.limits);
-    const postHook = parsePostHook(value.postHook, "submission.postHook");
     const proxyEndpoints = parseProxyEndpoints(value.proxyEndpoints);
     const secrets = parseInlineSecrets(value.secrets);
     enforceCredentialSecretPolicy(secrets, provider, {
@@ -1062,7 +1059,6 @@ export function parseRunSubmissionRequest(input, options = {}) {
         submission,
         ...(runtimeSize ? { runtimeSize } : {}),
         ...(timeoutMs !== undefined ? { timeoutMs } : {}),
-        ...(postHook !== undefined ? { postHook } : {}),
         ...(proxyEndpoints ? { proxyEndpoints } : {}),
         ...(parentRunId !== undefined ? { parentRunId } : {}),
         ...(webhook !== undefined ? { webhook } : {}),