@aexhq/sdk 0.40.16 → 0.41.0

package/dist/_contracts/{run-retention.js → session-retention.js}

@@ -1,13 +1,13 @@
-import { isTerminalRunStatus } from "./status.js";
-export const RUN_RETENTION_SCHEMA_VERSION = 1;
-export const RUN_DELETION_MANIFEST_KIND = "aex.run_deletion_manifest.v1";
-export const RUN_DELETION_JOB_KIND = "aex.run_deletion_job.v1";
-export const RUN_DELETION_MANIFEST_CONTENT_TYPE = "application/json; charset=utf-8";
-export const RUN_RETENTION_REDACTION_SCANNER_VERSION = 1;
-export const RUN_DELETION_REASONS = ["manual_delete", "retention_gc"];
-export const RUN_DELETION_MANIFEST_MODES = ["dry_run", "final"];
-export const RUN_DELETION_CANDIDATE_STATUSES = ["selected", "blocked"];
-export const RUN_DELETION_BLOCKERS = [
+import { isTerminalSessionControlStatus } from "./status.js";
+export const SESSION_RETENTION_SCHEMA_VERSION = 1;
+export const SESSION_DELETION_MANIFEST_KIND = "aex.session_deletion_manifest.v1";
+export const SESSION_DELETION_JOB_KIND = "aex.session_deletion_job.v1";
+export const SESSION_DELETION_MANIFEST_CONTENT_TYPE = "application/json; charset=utf-8";
+export const SESSION_RETENTION_REDACTION_SCANNER_VERSION = 1;
+export const SESSION_DELETION_REASONS = ["manual_delete", "retention_gc"];
+export const SESSION_DELETION_MANIFEST_MODES = ["dry_run", "final"];
+export const SESSION_DELETION_CANDIDATE_STATUSES = ["selected", "blocked"];
+export const SESSION_DELETION_BLOCKERS = [
     "non_terminal",
     "retention_policy_disabled",
     "unexpired",
@@ -16,20 +16,20 @@ export const RUN_DELETION_BLOCKERS = [
     "unresolved_cleanup",
     "unresolved_custody"
 ];
-export const RUN_DELETION_COUNT_CLASSES = [
+export const SESSION_DELETION_COUNT_CLASSES = [
     "object_store_objects",
-    "outputs",
+    "files",
     "logs",
     "events",
     "assets",
     "db_event_rows",
-    "db_output_rows",
+    "db_file_rows",
     "capture_failures",
     "storage_samples",
     "custody_manifests"
 ];
-export const RUN_DELETION_COUNT_STATUSES = ["counted", "not_counted", "partial", "failed"];
-export const RUN_DELETION_JOB_STATUSES = [
+export const SESSION_DELETION_COUNT_STATUSES = ["counted", "not_counted", "partial", "failed"];
+export const SESSION_DELETION_JOB_STATUSES = [
     "queued",
     "planning",
     "blocked",
@@ -39,14 +39,14 @@ export const RUN_DELETION_JOB_STATUSES = [
     "completed",
     "failed"
 ];
-export const RUN_DELETION_PROOF_STATUSES = [
+export const SESSION_DELETION_PROOF_STATUSES = [
     "not_started",
     "running",
     "completed",
     "failed"
 ];
-export const RUN_DELETION_WRITE_STATUSES = ["not_written", "written", "write_failed"];
-export const RUN_RETENTION_EXCLUDED_VALUE_CLASSES = [
+export const SESSION_DELETION_WRITE_STATUSES = ["not_written", "written", "write_failed"];
+export const SESSION_RETENTION_EXCLUDED_VALUE_CLASSES = [
     "raw_paths",
     "object_keys",
     "filenames",
@@ -58,67 +58,67 @@ export const RUN_RETENTION_EXCLUDED_VALUE_CLASSES = [
     "resource_handles",
     "signed_urls"
 ];
-export class RunRetentionValidationError extends Error {
-    code = "run_retention_contract_invalid";
+export class SessionRetentionValidationError extends Error {
+    code = "session_retention_contract_invalid";
     constructor(message) {
         super(message);
-        this.name = "RunRetentionValidationError";
+        this.name = "SessionRetentionValidationError";
     }
 }
-export class RunRetentionRedactionError extends Error {
-    code = "run_retention_payload_not_public_safe";
+export class SessionRetentionRedactionError extends Error {
+    code = "session_retention_payload_not_public_safe";
     findings;
     constructor(findings) {
-        super(`run retention payload contains non-public data at ${formatFindingPaths(findings)}`);
-        this.name = "RunRetentionRedactionError";
+        super(`session retention payload contains non-public data at ${formatFindingPaths(findings)}`);
+        this.name = "SessionRetentionRedactionError";
         this.findings = Object.freeze([...findings]);
     }
 }
-export class FakeRunDeletionManifestObjectStore {
+export class FakeSessionDeletionManifestObjectStore {
     #objects = new Map();
-    async putRunDeletionManifestObject(object) {
-        assertPublicSafeRunRetentionPayload(object.manifest);
-        this.#objects.set(object.runId, cloneJson(object.manifest));
+    async putSessionDeletionManifestObject(object) {
+        assertPublicSafeSessionRetentionPayload(object.manifest);
+        this.#objects.set(object.sessionId, cloneJson(object.manifest));
     }
-    getByRunId(runId) {
-        return this.get(runId);
+    getBySessionId(sessionId) {
+        return this.get(sessionId);
     }
-    get(runId) {
-        const object = this.#objects.get(runId);
+    get(sessionId) {
+        const object = this.#objects.get(sessionId);
         return object ? cloneJson(object) : undefined;
     }
-    listRunIds() {
+    listSessionIds() {
         return Object.freeze([...this.#objects.keys()].sort());
     }
 }
-export function createRunDeletionManifestWriter(store) {
+export function createSessionDeletionManifestWriter(store) {
     return {
-        async writeRunDeletionManifest(input) {
-            return writeRunDeletionManifest(store, input);
+        async writeSessionDeletionManifest(input) {
+            return writeSessionDeletionManifest(store, input);
         }
     };
 }
-export async function writeRunDeletionManifest(store, input) {
-    const manifest = buildRunDeletionManifest(input);
-    await store.putRunDeletionManifestObject({
-        runId: manifest.run.runId,
-        workspaceId: manifest.run.workspaceId,
-        contentType: RUN_DELETION_MANIFEST_CONTENT_TYPE,
+export async function writeSessionDeletionManifest(store, input) {
+    const manifest = buildSessionDeletionManifest(input);
+    await store.putSessionDeletionManifestObject({
+        sessionId: manifest.session.sessionId,
+        workspaceId: manifest.session.workspaceId,
+        contentType: SESSION_DELETION_MANIFEST_CONTENT_TYPE,
         manifest
     });
     return Object.freeze({
         status: "written",
-        schemaVersion: RUN_RETENTION_SCHEMA_VERSION,
-        runId: manifest.run.runId,
-        workspaceId: manifest.run.workspaceId,
+        schemaVersion: SESSION_RETENTION_SCHEMA_VERSION,
+        sessionId: manifest.session.sessionId,
+        workspaceId: manifest.session.workspaceId,
         writtenAt: manifest.generatedAt,
         mode: manifest.mode
     });
 }
-export function buildRunRetentionPolicy(input = {}) {
+export function buildSessionRetentionPolicy(input = {}) {
     if (input.automaticDeletion) {
         if (input.retentionDays === undefined) {
-            throw new RunRetentionValidationError("automatic retention deletion requires an explicit positive retentionDays value");
+            throw new SessionRetentionValidationError("automatic retention deletion requires an explicit positive retentionDays value");
         }
         return Object.freeze({
             mode: "delete_after_days",
@@ -128,7 +128,7 @@ export function buildRunRetentionPolicy(input = {}) {
         });
     }
     if (input.retentionDays !== undefined) {
-        throw new RunRetentionValidationError("retentionDays is not allowed when automatic retention deletion is disabled");
+        throw new SessionRetentionValidationError("retentionDays is not allowed when automatic retention deletion is disabled");
     }
     return Object.freeze({
         mode: "retain_indefinitely",
@@ -136,19 +136,19 @@ export function buildRunRetentionPolicy(input = {}) {
         automaticDeletion: "disabled"
     });
 }
-export function evaluateRunDeletionCandidate(input) {
+export function evaluateSessionDeletionCandidate(input) {
     const now = assertTimestamp(input.now, "candidate.now");
-    const run = normalizeCandidateRun(input.run);
+    const session = normalizeCandidateSession(input.session);
     const policy = normalizePolicy(input.policy);
     const blockers = [];
-    addRunBlockers(blockers, run, now);
+    addSessionBlockers(blockers, session, now);
     let eligibleAt;
     if (input.reason === "retention_gc") {
         if (policy.mode !== "delete_after_days" || policy.retentionDays === undefined) {
             blockers.push(blocker("retention_policy_disabled", now));
         }
-        else if (run.terminalAt) {
-            eligibleAt = addDaysIso(run.terminalAt, policy.retentionDays);
+        else if (session.terminalAt) {
+            eligibleAt = addDaysIso(session.terminalAt, policy.retentionDays);
             if (Date.parse(now) < Date.parse(eligibleAt)) {
                 blockers.push(blocker("unexpired", now));
             }
@@ -165,53 +165,53 @@ export function evaluateRunDeletionCandidate(input) {
         blockers: Object.freeze(blockers)
     });
 }
-export function buildRunDeletionManifest(input) {
+export function buildSessionDeletionManifest(input) {
     const candidate = input.candidate ??
-        evaluateRunDeletionCandidate({
-            run: input.run,
+        evaluateSessionDeletionCandidate({
+            session: input.session,
             reason: input.request.reason,
             now: input.generatedAt,
             ...(input.policy ? { policy: input.policy } : {})
         });
     const normalizedCandidate = normalizeCandidate(candidate);
-    const run = normalizeManifestRun(input.run, normalizedCandidate.eligibleAt);
-    const summary = buildRunDeletionSummary(input.counts ?? [], normalizedCandidate);
+    const session = normalizeManifestSession(input.session, normalizedCandidate.eligibleAt);
+    const summary = buildSessionDeletionSummary(input.counts ?? [], normalizedCandidate);
     const manifest = Object.freeze({
-        schemaVersion: RUN_RETENTION_SCHEMA_VERSION,
-        kind: RUN_DELETION_MANIFEST_KIND,
+        schemaVersion: SESSION_RETENTION_SCHEMA_VERSION,
+        kind: SESSION_DELETION_MANIFEST_KIND,
         generatedAt: assertTimestamp(input.generatedAt, "manifest.generatedAt"),
         mode: input.mode,
-        run,
+        session,
         request: normalizeRequest(input.request),
         candidate: normalizedCandidate,
         summary,
         redaction: Object.freeze({
             policy: "counts_status_timestamps_only",
-            scannerVersion: RUN_RETENTION_REDACTION_SCANNER_VERSION,
-            excludes: Object.freeze([...RUN_RETENTION_EXCLUDED_VALUE_CLASSES])
+            scannerVersion: SESSION_RETENTION_REDACTION_SCANNER_VERSION,
+            excludes: Object.freeze([...SESSION_RETENTION_EXCLUDED_VALUE_CLASSES])
         })
     });
-    assertPublicSafeRunRetentionPayload(manifest);
+    assertPublicSafeSessionRetentionPayload(manifest);
     return manifest;
 }
-export function assertRunDeletionOrder(proof) {
+export function assertSessionDeletionOrder(proof) {
     const manifest = normalizeManifestProof(proof.manifest);
     const purge = normalizePurgeProof(proof.purge);
     const purgeStarted = purge.status === "running" || purge.status === "completed" || purge.status === "failed";
     if (purgeStarted && manifest.status !== "written") {
-        throw new RunRetentionValidationError("run deletion cannot purge assets before the deletion manifest is written");
+        throw new SessionRetentionValidationError("session deletion cannot purge assets before the deletion manifest is written");
     }
     if (purgeStarted && manifest.mode !== "final") {
-        throw new RunRetentionValidationError("run deletion cannot purge assets from a dry-run deletion manifest");
+        throw new SessionRetentionValidationError("session deletion cannot purge assets from a dry-run deletion manifest");
     }
 }
-export function buildRunDeletionJob(input) {
-    assertRunDeletionOrder(input.order);
+export function buildSessionDeletionJob(input) {
+    assertSessionDeletionOrder(input.order);
     const job = Object.freeze({
-        schemaVersion: RUN_RETENTION_SCHEMA_VERSION,
-        kind: RUN_DELETION_JOB_KIND,
+        schemaVersion: SESSION_RETENTION_SCHEMA_VERSION,
+        kind: SESSION_DELETION_JOB_KIND,
         jobId: assertSafeIdentifier(input.jobId, "job.jobId"),
-        runId: assertSafeIdentifier(input.runId, "job.runId"),
+        sessionId: assertSafeIdentifier(input.sessionId, "job.sessionId"),
         workspaceId: assertSafeIdentifier(input.workspaceId, "job.workspaceId"),
         reason: input.reason,
         mode: input.mode,
@@ -222,63 +222,63 @@ export function buildRunDeletionJob(input) {
         ...(input.candidate ? { candidate: normalizeCandidate(input.candidate) } : {}),
         ...(input.summary ? { summary: normalizeSummary(input.summary) } : {})
     });
-    assertPublicSafeRunRetentionPayload(job);
+    assertPublicSafeSessionRetentionPayload(job);
     return job;
 }
-export function scanRunRetentionPayloadForSensitiveValues(input) {
+export function scanSessionRetentionPayloadForSensitiveValues(input) {
     const findings = [];
     visitRetentionValue(input, "$", findings);
     return Object.freeze(findings);
 }
-export function assertPublicSafeRunRetentionPayload(input) {
-    const findings = scanRunRetentionPayloadForSensitiveValues(input);
+export function assertPublicSafeSessionRetentionPayload(input) {
+    const findings = scanSessionRetentionPayloadForSensitiveValues(input);
     if (findings.length > 0) {
-        throw new RunRetentionRedactionError(findings);
+        throw new SessionRetentionRedactionError(findings);
     }
 }
 function normalizePolicy(input) {
     if (!input) {
-        return buildRunRetentionPolicy();
+        return buildSessionRetentionPolicy();
     }
     if ("mode" in input) {
         if (input.mode === "delete_after_days") {
             if (input.retentionDays === undefined) {
-                throw new RunRetentionValidationError("delete_after_days retention policy requires an explicit retentionDays value");
+                throw new SessionRetentionValidationError("delete_after_days retention policy requires an explicit retentionDays value");
             }
-            return buildRunRetentionPolicy({
+            return buildSessionRetentionPolicy({
                 automaticDeletion: true,
                 retentionDays: input.retentionDays
             });
         }
         if (input.retentionDays !== undefined) {
-            throw new RunRetentionValidationError("retain_indefinitely retention policy cannot include retentionDays");
+            throw new SessionRetentionValidationError("retain_indefinitely retention policy cannot include retentionDays");
         }
-        return buildRunRetentionPolicy();
+        return buildSessionRetentionPolicy();
     }
-    return buildRunRetentionPolicy(input);
+    return buildSessionRetentionPolicy(input);
 }
-function normalizeCandidateRun(input) {
+function normalizeCandidateSession(input) {
     return Object.freeze({
-        runId: assertSafeIdentifier(input.runId, "run.runId"),
-        workspaceId: assertSafeIdentifier(input.workspaceId, "run.workspaceId"),
-        status: assertSafeMetadataString(input.status, "run.status"),
-        ...(input.createdAt ? { createdAt: assertTimestamp(input.createdAt, "run.createdAt") } : {}),
-        ...(input.terminalAt ? { terminalAt: assertTimestamp(input.terminalAt, "run.terminalAt") } : {}),
+        sessionId: assertSafeIdentifier(input.sessionId, "session.sessionId"),
+        workspaceId: assertSafeIdentifier(input.workspaceId, "session.workspaceId"),
+        status: assertSafeMetadataString(input.status, "session.status"),
+        ...(input.createdAt ? { createdAt: assertTimestamp(input.createdAt, "session.createdAt") } : {}),
+        ...(input.terminalAt ? { terminalAt: assertTimestamp(input.terminalAt, "session.terminalAt") } : {}),
         ...(input.held !== undefined ? { held: input.held } : {}),
         ...(input.retentionExempt !== undefined ? { retentionExempt: input.retentionExempt } : {}),
         ...(input.unresolvedCleanup !== undefined ? { unresolvedCleanup: input.unresolvedCleanup } : {}),
         ...(input.unresolvedCustody !== undefined ? { unresolvedCustody: input.unresolvedCustody } : {})
     });
 }
-function normalizeManifestRun(input, eligibleAt) {
-    const run = normalizeCandidateRun(input);
+function normalizeManifestSession(input, eligibleAt) {
+    const session = normalizeCandidateSession(input);
     return Object.freeze({
-        runId: run.runId,
-        workspaceId: run.workspaceId,
-        status: run.status,
-        ...(run.createdAt ? { createdAt: run.createdAt } : {}),
-        ...(run.terminalAt ? { terminalAt: run.terminalAt } : {}),
-        ...(eligibleAt ? { eligibleAt: assertTimestamp(eligibleAt, "run.eligibleAt") } : {})
+        sessionId: session.sessionId,
+        workspaceId: session.workspaceId,
+        status: session.status,
+        ...(session.createdAt ? { createdAt: session.createdAt } : {}),
+        ...(session.terminalAt ? { terminalAt: session.terminalAt } : {}),
+        ...(eligibleAt ? { eligibleAt: assertTimestamp(eligibleAt, "session.eligibleAt") } : {})
     });
 }
 function normalizeRequest(input) {
@@ -311,7 +311,7 @@ function normalizeCount(input) {
         ...(input.errorClass ? { errorClass: assertSafeMetadataString(input.errorClass, "summary.count.errorClass") } : {})
     });
 }
-function buildRunDeletionSummary(input, candidate) {
+function buildSessionDeletionSummary(input, candidate) {
     const counts = Object.freeze(input.map(normalizeCount));
     return Object.freeze({
         totalCount: counts.reduce((sum, item) => sum + item.count, 0),
@@ -353,20 +353,20 @@ function normalizePurgeProof(input) {
             : {})
     });
 }
-function addRunBlockers(blockers, run, observedAt) {
-    if (!isTerminalStatusLike(run.status)) {
+function addSessionBlockers(blockers, session, observedAt) {
+    if (!isTerminalStatusLike(session.status)) {
         blockers.push(blocker("non_terminal", observedAt));
     }
-    if (run.held) {
+    if (session.held) {
         blockers.push(blocker("held", observedAt));
     }
-    if (run.retentionExempt) {
+    if (session.retentionExempt) {
         blockers.push(blocker("retention_exempt", observedAt));
     }
-    if (run.unresolvedCleanup) {
+    if (session.unresolvedCleanup) {
         blockers.push(blocker("unresolved_cleanup", observedAt));
     }
-    if (run.unresolvedCustody) {
+    if (session.unresolvedCustody) {
         blockers.push(blocker("unresolved_custody", observedAt));
     }
 }
@@ -374,10 +374,10 @@ function blocker(code, observedAt) {
     return Object.freeze({ code, observedAt });
 }
 function isTerminalStatusLike(status) {
-    return isTerminalRunStatus(status);
+    return isTerminalSessionControlStatus(status);
 }
 function addDaysIso(timestamp, days) {
-    const start = Date.parse(assertTimestamp(timestamp, "candidate.run.terminalAt"));
+    const start = Date.parse(assertTimestamp(timestamp, "candidate.session.terminalAt"));
     const end = start + positiveInteger(days, "policy.retentionDays") * 24 * 60 * 60 * 1000;
     return new Date(end).toISOString();
 }
@@ -414,11 +414,11 @@ function scanStringValue(value, path, findings) {
 }
 const forbiddenStringPatterns = Object.freeze([
     { reason: "signed_url", regex: /[?&](?:X-Amz-Signature|X-Amz-Credential|X-Amz-Algorithm|AWSAccessKeyId)=/i },
-    { reason: "object_store_key", regex: /(^|[\s"'`])(?:runs|assets)\/[^?<#\s"'`]+/i },
+    { reason: "object_store_key", regex: /(^|[\s"'`])(?:sessions|assets)\/[^?<#\s"'`]+/i },
     { reason: "vault_id", regex: /\b(?:vault|vlt|secret)[_:-][A-Za-z0-9][A-Za-z0-9_-]{7,}\b/i },
     {
         reason: "private_resource_handle",
-        regex: /\b(?:machine|session|resource|handle|provider|asset)[_:-][A-Za-z0-9][A-Za-z0-9_-]{7,}\b/i
+        regex: /\b(?:machine|resource|handle|provider|asset)[_:-][A-Za-z0-9][A-Za-z0-9_-]{7,}\b/i
     },
     { reason: "hash_like_value", regex: /\b(?:sha256|hash)[:_-][A-Fa-f0-9]{16,}\b/ }
 ]);
@@ -428,38 +428,38 @@ function isForbiddenRetentionFieldName(key) {
 function assertSafeIdentifier(value, field) {
     assertNonEmptyString(value, field);
     if (!/^[A-Za-z0-9._:-]+$/.test(value)) {
-        throw new RunRetentionValidationError(`run retention ${field} must be an opaque identifier without path separators`);
+        throw new SessionRetentionValidationError(`session retention ${field} must be an opaque identifier without path separators`);
     }
-    assertPublicSafeRunRetentionPayload(value);
+    assertPublicSafeSessionRetentionPayload(value);
     return value;
 }
 function assertSafeMetadataString(value, field) {
     assertNonEmptyString(value, field);
-    assertPublicSafeRunRetentionPayload(value);
+    assertPublicSafeSessionRetentionPayload(value);
     return value;
 }
 function assertNonEmptyString(value, field) {
     if (typeof value !== "string" || value.trim().length === 0) {
-        throw new RunRetentionValidationError(`run retention ${field} must be a non-empty string`);
+        throw new SessionRetentionValidationError(`session retention ${field} must be a non-empty string`);
     }
 }
 function assertTimestamp(value, field) {
     assertSafeMetadataString(value, field);
     const ms = Date.parse(value);
     if (!Number.isFinite(ms)) {
-        throw new RunRetentionValidationError(`run retention ${field} must be an ISO timestamp string`);
+        throw new SessionRetentionValidationError(`session retention ${field} must be an ISO timestamp string`);
     }
     return value;
 }
 function nonNegativeInteger(value, field) {
     if (!Number.isSafeInteger(value) || value < 0) {
-        throw new RunRetentionValidationError(`run retention ${field} must be a non-negative safe integer`);
+        throw new SessionRetentionValidationError(`session retention ${field} must be a non-negative safe integer`);
     }
     return value;
 }
 function positiveInteger(value, field) {
     if (!Number.isSafeInteger(value) || value <= 0) {
-        throw new RunRetentionValidationError(`run retention ${field} must be a positive safe integer`);
+        throw new SessionRetentionValidationError(`session retention ${field} must be a positive safe integer`);
     }
     return value;
 }

package/dist/_contracts/{run-unit.d.ts → session-unit.d.ts}

@@ -1,13 +1,13 @@
 /**
- * RunUnit — the self-contained read shape of a run.
+ * SessionUnit — the self-contained read shape of a session.
  *
  * One canonical struct that captures every non-secret artifact persisted
- * for a single run: parsed submission inputs, status/lifecycle, attempts,
- * indexed events, raw-event Storage manifest, outputs, and capture failures.
+ * for a single session: parsed submission inputs, status/lifecycle, attempts,
+ * indexed events, raw-event Storage manifest, session files, and capture failures.
  *
- * Wire contract for `GET /api/runs/:runId`, the per-run archive's
- * `run.json`/`submission.json`/`caps.json`, and the SDK/CLI
- * `client.runs.get(runId)` return type.
+ * Wire contract for `GET /api/sessions/:sessionId`, the per-session archive's
+ * `session.json`/`submission.json`/`caps.json`, and the SDK/CLI
+ * `client.sessions.get(sessionId)` return type.
  *
  * Immutability: every field here is read-only. Edit endpoints do not
  * exist by design.
@@ -20,16 +20,16 @@
 import type { CleanupStatus } from "./status.js";
 import type { JsonValue, PlatformSubmission } from "./submission.js";
 /**
- * Parsed view of the legacy run snapshot jsonb. Stored shape is
+ * Parsed view of the legacy session snapshot jsonb. Stored shape is
  * `{kind:"submission", submission}` written by the hosted API's
- * server-side run creation for all runs.
+ * server-side session creation for all sessions.
  */
-export type RunUnitSubmission = RunUnitFlatSubmission;
-export interface RunUnitFlatSubmission {
+export type SessionUnitSubmission = SessionUnitFlatSubmission;
+export interface SessionUnitFlatSubmission {
     readonly kind: "submission";
     readonly submission: PlatformSubmission;
 }
-export interface RunUnitAttempt {
+export interface SessionUnitAttempt {
     readonly id: string;
     readonly attemptNumber: number;
     readonly status: string;
@@ -46,7 +46,7 @@ export interface RunUnitAttempt {
  * each event are NOT here — they ride in `rawEventPages`. This struct
  * stays small so the detail response is bounded.
  */
-export interface RunUnitEvent {
+export interface SessionUnitEvent {
     readonly id: string;
     readonly attemptId?: string;
     readonly providerEventId?: string;
@@ -58,21 +58,21 @@ export interface RunUnitEvent {
 }
 /**
  * Inline slice of events plus an optional cursor for the tail. Most
- * runs fit entirely inline; long-running ones overflow and the
- * consumer paginates via `GET /api/runs/:runId/events?cursor=...`.
+ * sessions fit entirely inline; long-running ones overflow and the
+ * consumer paginates via `GET /api/sessions/:sessionId/events?cursor=...`.
  */
-export interface RunUnitEventPage {
-    readonly entries: readonly RunUnitEvent[];
+export interface SessionUnitEventPage {
+    readonly entries: readonly SessionUnitEvent[];
     readonly totalCount: number;
     readonly truncated: boolean;
     readonly nextCursor?: string;
 }
 /**
- * One gzipped JSONL page of raw provider events captured for the run record.
+ * One gzipped JSONL page of raw provider events captured for the session record.
  * Bytes are downloaded through auth-gated routes or surfaced inside the
- * per-run archive zip. `artifactPath` is run-record relative.
+ * per-session archive zip. `artifactPath` is session-record relative.
  */
-export interface RunUnitRawEventPage {
+export interface SessionUnitRawEventPage {
     readonly attempt: number;
     readonly page: number;
     readonly byteSize: number;
@@ -81,13 +81,13 @@ export interface RunUnitRawEventPage {
     readonly contentEncoding: "gzip";
     readonly createdAt: string;
 }
-export interface RunUnitOutput {
+export interface SessionUnitFile {
     readonly id: string;
     readonly fileName: string;
     readonly byteSize: number;
     readonly contentType?: string;
 }
-export interface RunUnitOutputCaptureFailure {
+export interface SessionUnitFileCaptureFailure {
     readonly id: string;
     readonly providerFileId?: string;
     readonly filename?: string;
@@ -96,7 +96,7 @@ export interface RunUnitOutputCaptureFailure {
     readonly errorMessage?: string;
     readonly createdAt: string;
 }
-export interface RunUnit {
+export interface SessionUnit {
     readonly id: string;
     readonly workspaceId: string;
     readonly status: string;
@@ -108,16 +108,16 @@ export interface RunUnit {
     readonly terminalAt?: string;
     readonly deletedAt?: string;
     readonly attemptCount: number;
-    readonly submission: RunUnitSubmission;
+    readonly submission: SessionUnitSubmission;
     readonly capsSnapshot?: Record<string, JsonValue>;
-    readonly attempts: readonly RunUnitAttempt[];
-    readonly events: RunUnitEventPage;
-    readonly rawEventPages: readonly RunUnitRawEventPage[];
-    readonly outputs: readonly RunUnitOutput[];
-    readonly outputCaptureFailures: readonly RunUnitOutputCaptureFailure[];
-    readonly costTelemetry?: import("./run-cost.js").RunCostTelemetry;
+    readonly attempts: readonly SessionUnitAttempt[];
+    readonly events: SessionUnitEventPage;
+    readonly rawEventPages: readonly SessionUnitRawEventPage[];
+    readonly sessionFiles: readonly SessionUnitFile[];
+    readonly fileCaptureFailures: readonly SessionUnitFileCaptureFailure[];
+    readonly costTelemetry?: import("./session-cost.js").SessionCostTelemetry;
     /**
-     * Per-run, per-provider runtime manifest — derived from the validated
+     * Per-session, per-provider runtime manifest — derived from the validated
      * submission + the chosen provider (`buildRuntimeManifest`). Tells
      * SDK consumers where aex placed things in-container and what
      * env vars the agent will see. Undefined on responses from BFFs
@@ -126,7 +126,7 @@ export interface RunUnit {
     readonly runtimeManifest?: import("./runtime-manifest.js").RuntimeManifest;
 }
 /**
- * Parse a legacy run snapshot jsonb payload into the typed flat
+ * Parse a legacy session snapshot jsonb payload into the typed flat
  * submission. Never throws on minor unknown keys so we can
  * forward-compat with hosted API enrichment.
  *
@@ -135,16 +135,16 @@ export interface RunUnit {
  * must still render *something* for a buggy historical row rather than 500ing
  * the whole detail page.
  */
-export declare function parseRunUnitSubmission(input: unknown, fallbackModel?: unknown): RunUnitSubmission;
+export declare function parseSessionUnitSubmission(input: unknown, fallbackModel?: unknown): SessionUnitSubmission;
 /**
- * Normalize a `GET /api/runs/:runId` payload into a RunUnit whose type contract
+ * Normalize a `GET /api/sessions/:sessionId` payload into a SessionUnit whose type contract
  * holds AT RUNTIME. The managed (AWS) plane returns a LEAN record (scalars +
- * costTelemetry only) and omits the aggregate collections; the RunUnit type
- * declares those non-optional, so a naive cast leaves `unit.outputs` /
+ * costTelemetry only) and omits the aggregate collections; the SessionUnit type
+ * declares those non-optional, so a naive cast leaves `unit.sessionFiles` /
  * `unit.events.totalCount` `undefined` and a typed consumer crashes on
  * `.map()` / `.totalCount` (pre-launch edge-sweep F25). We fill the aggregates
  * with their empty defaults so array/page access is always safe. NOTE: on the
- * managed plane these summaries are best-effort — read `outputs()` / `events()`
- * / `messages()` for the authoritative per-run data.
+ * managed plane these summaries are best-effort — read `files()` / `events()`
+ * / `messages()` for the authoritative per-session data.
  */
-export declare function normalizeRunUnit(raw: unknown): RunUnit;
+export declare function normalizeSessionUnit(raw: unknown): SessionUnit;