@aexhq/sdk 0.40.16 → 0.41.0

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

@@ -2,7 +2,7 @@ export const CUSTODY_MANIFEST_SCHEMA_VERSION = 1;
 export const CUSTODY_REDACTION_SCANNER_VERSION = 1;
 export const CUSTODY_MANIFEST_KIND = "aex.custody_manifest.v1";
 export const CUSTODY_MANIFEST_CONTENT_TYPE = "application/json; charset=utf-8";
-export const CUSTODY_MANIFEST_RUN_REL_PATH = "metadata/custody.json";
+export const CUSTODY_MANIFEST_SESSION_REL_PATH = "metadata/custody.json";
 export const CUSTODY_SECRET_CLASSES = [
     "provider_api_key",
     "mcp_credential",
@@ -15,9 +15,9 @@ export const CUSTODY_RESOURCE_CLASSES = [
     "proxy_token",
     "execution_secret",
     "event_archive",
-    "run_output",
-    "run_log",
-    "run_asset"
+    "session_file",
+    "session_log",
+    "session_asset"
 ];
 export const CUSTODY_EXPOSURE_SURFACES = [
     "aex_vault",
@@ -27,7 +27,7 @@ export const CUSTODY_EXPOSURE_SURFACES = [
     "dashboard_proxy",
     "api_provider_proxy",
     "api_mcp_proxy",
-    "run_artifact_store",
+    "session_artifact_store",
     "coordinator_event_archive"
 ];
 export const CUSTODY_EXPOSURE_ACCESS_KINDS = [
@@ -63,11 +63,11 @@ export const CUSTODY_CLEANUP_STATUSES = [
     "pending"
 ];
 export const CUSTODY_EVIDENCE_SOURCES = [
-    "run_row",
+    "session_row",
     "runtime_manifest",
     "terminal_event",
     "cleanup_step",
-    "output_capture",
+    "file_capture",
     "proxy_audit",
     "provider_cleanup_summary"
 ];
@@ -95,8 +95,8 @@ export class FakeCustodyManifestObjectStore {
         assertPublicSafeCustodyPayload(object.manifest);
         this.#objects.set(object.key, cloneJson(object.manifest));
     }
-    getByRunId(runId) {
-        return this.get(custodyManifestObjectKey(runId));
+    getBySessionId(sessionId) {
+        return this.get(custodyManifestObjectKey(sessionId));
     }
     get(key) {
         const object = this.#objects.get(key);
@@ -106,9 +106,9 @@ export class FakeCustodyManifestObjectStore {
         return Object.freeze([...this.#objects.keys()].sort());
     }
 }
-export function custodyManifestObjectKey(runId) {
-    assertSafeIdentifier(runId, "runId");
-    return `runs/${runId}/${CUSTODY_MANIFEST_RUN_REL_PATH}`;
+export function custodyManifestObjectKey(sessionId) {
+    assertSafeIdentifier(sessionId, "sessionId");
+    return `sessions/${sessionId}/${CUSTODY_MANIFEST_SESSION_REL_PATH}`;
 }
 export function createCustodyManifestWriter(store) {
     return {
@@ -119,7 +119,7 @@ export function createCustodyManifestWriter(store) {
 }
 export async function writeCustodyManifest(store, input) {
     const manifest = buildCustodyManifest(input);
-    const key = custodyManifestObjectKey(manifest.run.runId);
+    const key = custodyManifestObjectKey(manifest.session.sessionId);
     await store.putCustodyManifestObject({
         key,
         contentType: CUSTODY_MANIFEST_CONTENT_TYPE,
@@ -128,8 +128,8 @@ export async function writeCustodyManifest(store, input) {
     return Object.freeze({
         status: "written",
         schemaVersion: CUSTODY_MANIFEST_SCHEMA_VERSION,
-        runId: manifest.run.runId,
-        workspaceId: manifest.run.workspaceId,
+        sessionId: manifest.session.sessionId,
+        workspaceId: manifest.session.workspaceId,
         key,
         writtenAt: manifest.finalizedAt ?? manifest.generatedAt
     });
@@ -143,7 +143,7 @@ export function buildCustodyManifest(input) {
         kind: CUSTODY_MANIFEST_KIND,
         generatedAt: assertTimestamp(input.generatedAt, "generatedAt"),
         ...(input.finalizedAt ? { finalizedAt: assertTimestamp(input.finalizedAt, "finalizedAt") } : {}),
-        run: normalizeRun(input.run),
+        session: normalizeSession(input.session),
         secrets,
         resources,
         cleanup,
@@ -168,14 +168,14 @@ export function assertPublicSafeCustodyPayload(input) {
         throw new CustodyManifestRedactionError(findings);
     }
 }
-function normalizeRun(input) {
+function normalizeSession(input) {
     return Object.freeze({
-        runId: assertSafeIdentifier(input.runId, "run.runId"),
-        workspaceId: assertSafeIdentifier(input.workspaceId, "run.workspaceId"),
-        provider: assertSafeMetadataString(input.provider, "run.provider"),
-        terminalStatus: assertSafeMetadataString(input.terminalStatus, "run.terminalStatus"),
-        ...(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"),
+        provider: assertSafeMetadataString(input.provider, "session.provider"),
+        terminalStatus: assertSafeMetadataString(input.terminalStatus, "session.terminalStatus"),
+        ...(input.createdAt ? { createdAt: assertTimestamp(input.createdAt, "session.createdAt") } : {}),
+        ...(input.terminalAt ? { terminalAt: assertTimestamp(input.terminalAt, "session.terminalAt") } : {})
     });
 }
 function normalizeSecretClass(input) {
@@ -329,8 +329,8 @@ function scanStringValue(value, path, findings) {
 }
 /**
  * A pattern fires on a value if its `regex` matches AND — when the pattern
- * carries an `accept` predicate — at least one matched run is accepted by it.
- * The predicate lets a shape-matched run be VETOED per-match (the entropy
+ * carries an `accept` predicate — at least one matched sequence is accepted by it.
+ * The predicate lets a shape-matched sequence be VETOED per-match (the entropy
  * catch-all uses it to skip content-addressed hashes and low-entropy slugs that
  * its coarse regex would otherwise flag); shape-only patterns have no predicate.
  */
@@ -362,56 +362,56 @@ const forbiddenStringPatterns = Object.freeze([
         regex: /\b(?:sk-[A-Za-z0-9_-]{16,}|xox[baprs]-[A-Za-z0-9-]{8,}|AIza[A-Za-z0-9_-]{8,})/i
     },
     { 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",
-        // `<keyword><sep><id>` opaque handles (`session_a1B2c3D4e5`, `file_9f8e7d…`).
+        // `<keyword><sep><id>` opaque handles (`machine_a1B2c3D4e5`, `resource_9f8e7d...`).
         // The keyword set overlaps ordinary prose, so require the id segment to
         // carry a digit. That keeps genuine minted handles flagged while avoiding
         // dictionary-word chains such as `agent_decision_failure`.
-        regex: /\b(?:machine|session|agent|file|skill|env|resource|handle|token_hash|bearer_hash)[_:-][A-Za-z0-9][A-Za-z0-9_-]{7,}\b/i,
+        regex: /\b(?:machine|agent|resource|handle|token_hash|bearer_hash)[_:-][A-Za-z0-9][A-Za-z0-9_-]{7,}\b/i,
         accept: isMintedResourceHandle
     },
     {
         reason: "high_entropy_token",
-        // Catch-all for an unrecognised opaque secret blob. The candidate run
+        // Catch-all for an unrecognised opaque secret blob. The candidate sequence
         // EXCLUDES `_` (so `SCREAMING_SNAKE` env names and `slug_with_words` URL
-        // segments split instead of fusing into a phantom 40-char run — the live
+        // segments split instead of fusing into a phantom 40-char sequence — the live
         // false positive was `ted_season_2_peacock_official_discussion_thread` in
         // web-search result text and a fetched URL), and the `accept` predicate
         // vetoes content-addressed hashes (md5/sha1/sha256 digests — the platform's
-        // OWN asset filenames) and low-entropy / single-class runs so only genuine
+        // OWN asset filenames) and low-entropy / single-class sessions so only genuine
         // opaque secrets remain. Slash-bearing secrets (signed URLs, connection
         // strings, `Bearer …`) are covered by the named patterns above.
         regex: /\b[A-Za-z0-9-]{40,}\b/,
-        accept: isHighEntropySecretRun
+        accept: isHighEntropySecretSequence
     }
 ]);
 /** A content-addressed hash (md5/sha1/sha256 hex digest) — the platform's own
  * asset filenames and content references. Exempt from the entropy catch-all so
- * a captured output named after its sha256 (or a hash echoed in tool-result
- * text) is not misclassified as a leaked secret. */
-const CONTENT_HASH_RUN = /^(?:[0-9a-f]{32}|[0-9a-f]{40}|[0-9a-f]{64})$/i;
+ * a captured file named after its sha256 (or a hash echoed in tool-result text)
+ * is not misclassified as a leaked secret. */
+const CONTENT_HASH_SEQUENCE = /^(?:[0-9a-f]{32}|[0-9a-f]{40}|[0-9a-f]{64})$/i;
 /**
- * Decide whether a coarse `[A-Za-z0-9-]{40,}` run is a genuine opaque secret.
+ * Decide whether a coarse `[A-Za-z0-9-]{40,}` sequence is a genuine opaque secret.
  * Rejects content-addressed hashes, then requires both character-class
  * diversity (≥2 of lower/upper/digit) and high Shannon entropy — the property
  * that separates an opaque key blob from a long dictionary-ish identifier. A
  * real prefixless secret (base64url/alnum-mixed) clears both gates; a hash, a
- * hyphenated slug, or a single-class run does not.
+ * hyphenated slug, or a single-class sequence does not.
  */
-function isHighEntropySecretRun(run) {
-    if (CONTENT_HASH_RUN.test(run)) {
+function isHighEntropySecretSequence(sequence) {
+    if (CONTENT_HASH_SEQUENCE.test(sequence)) {
         return false;
     }
-    if (!/[A-Za-z]/.test(run) || !/\d/.test(run)) {
+    if (!/[A-Za-z]/.test(sequence) || !/\d/.test(sequence)) {
         return false;
     }
-    if (highEntropyCharClassCount(run) < 2) {
+    if (highEntropyCharClassCount(sequence) < 2) {
         return false;
     }
-    return highEntropyShannonBits(run) >= 3.0;
+    return highEntropyShannonBits(sequence) >= 3.0;
 }
 function isMintedResourceHandle(match) {
     const separatorIndex = match.search(/[_:-]/);

package/dist/_contracts/session-record.d.ts

@@ -0,0 +1,112 @@
+import type { SessionCostTelemetry } from "./session-cost.js";
+import { type CustodyManifestV1, type CustodyRedactionFinding } from "./session-custody.js";
+import type { AexEvent } from "./event-envelope.js";
+import type { SessionRecord, SessionFile } from "./runtime-types.js";
+import type { PlatformSubmission } from "./submission.js";
+export declare const SESSION_RECORD_SCHEMA_VERSION: "aex.session-record.v1";
+export declare const SESSION_RECORD_MANIFEST_SCHEMA_VERSION: "aex.session-record.manifest.v1";
+export type SessionRecordArchiveNamespaceV1 = "metadata" | "events" | "files";
+export type SessionRecordFileStatusV1 = "present" | "absent" | "pending" | "unavailable" | "not_applicable" | "error";
+export type SessionRecordArchiveFileRoleV1 = "session_metadata" | "submission_snapshot" | "cost" | "custody" | "typed_events" | "coordinator_events_manifest" | "file";
+export interface SessionRecordSubmissionSnapshotV1 {
+    readonly submission: PlatformSubmission;
+}
+export interface SessionRecordCostV1 {
+    readonly status: SessionRecordFileStatusV1;
+    readonly telemetry?: SessionCostTelemetry;
+}
+export interface SessionRecordMetadataV1 {
+    readonly session: SessionRecord;
+    readonly submission?: SessionRecordSubmissionSnapshotV1;
+    readonly cost?: SessionRecordCostV1;
+    readonly custody?: CustodyManifestV1;
+}
+export interface SessionRecordEventsV1 {
+    /** Typed `channel: "event"` records in the SDK `events/events.jsonl` export. */
+    readonly typed: readonly AexEvent[];
+}
+export interface SessionRecordV1 {
+    readonly schemaVersion: typeof SESSION_RECORD_SCHEMA_VERSION;
+    readonly sessionId: string;
+    readonly metadata: SessionRecordMetadataV1;
+    readonly events: SessionRecordEventsV1;
+    readonly sessionFiles: readonly SessionFile[];
+    readonly manifest: SessionRecordManifestV1;
+}
+export interface SessionRecordNamespaceV1 {
+    readonly name: SessionRecordArchiveNamespaceV1;
+    readonly prefix: `${SessionRecordArchiveNamespaceV1}/`;
+    readonly status: SessionRecordFileStatusV1;
+    readonly description: string;
+}
+export interface SessionRecordArchiveFileV1 {
+    readonly namespace: SessionRecordArchiveNamespaceV1;
+    readonly path: string;
+    readonly role: SessionRecordArchiveFileRoleV1;
+    readonly status: SessionRecordFileStatusV1;
+    readonly id?: string;
+    readonly filename?: string | null;
+    readonly sizeBytes?: number;
+    readonly contentType?: string;
+    readonly recordCount?: number;
+}
+export interface SessionRecordArtifactSummaryV1 {
+    readonly id: string;
+    readonly filename: string | null;
+    readonly sizeBytes?: number;
+    readonly contentType?: string;
+}
+export interface SessionRecordDownloadErrorV1 {
+    readonly namespace: "files";
+    readonly id: string;
+    readonly filename: string | null;
+    readonly message: string;
+}
+export interface SessionRecordManifestV1 {
+    readonly schemaVersion: typeof SESSION_RECORD_MANIFEST_SCHEMA_VERSION;
+    readonly sessionRecordSchemaVersion: typeof SESSION_RECORD_SCHEMA_VERSION;
+    readonly sessionId: string;
+    readonly namespaces: readonly SessionRecordNamespaceV1[];
+    readonly files: readonly SessionRecordArchiveFileV1[];
+    /** Captured session files included in the archive. */
+    readonly sessionFiles: readonly SessionRecordArtifactSummaryV1[];
+    readonly errors: readonly SessionRecordDownloadErrorV1[];
+}
+export interface BuildSessionRecordDownloadManifestV1Input {
+    readonly sessionId: string;
+    readonly sessionFiles: readonly SessionRecordArtifactSummaryV1[];
+    readonly errors?: readonly SessionRecordDownloadErrorV1[];
+    readonly typedEventCount?: number;
+    readonly submission?: SessionRecordFileManifestInputV1;
+    readonly cost?: SessionRecordFileManifestInputV1;
+    readonly custody?: SessionRecordFileManifestInputV1;
+    readonly coordinatorEventsManifest?: SessionRecordFileManifestInputV1;
+}
+export interface SessionRecordFileManifestInputV1 {
+    readonly status: SessionRecordFileStatusV1;
+    readonly recordCount?: number;
+}
+export interface SessionRecordArchiveEntryForRedactionV1 {
+    readonly path: string;
+    readonly bytes: Uint8Array;
+    readonly contentType?: string;
+    /**
+     * Customer-authored file bytes are intentionally outside the public-record
+     * redaction guarantee. Metadata, event exports, and manifests remain scanned.
+     */
+    readonly customerContent?: boolean;
+}
+export interface SessionRecordArchiveRedactionFindingV1 {
+    readonly entryPath: string;
+    readonly path: string;
+    readonly reason: CustodyRedactionFinding["reason"];
+    readonly valueLength?: number;
+}
+export declare class SessionRecordArchiveRedactionError extends Error {
+    readonly code = "session_record_archive_not_public_safe";
+    readonly findings: readonly SessionRecordArchiveRedactionFindingV1[];
+    constructor(findings: readonly SessionRecordArchiveRedactionFindingV1[]);
+}
+export declare function buildSessionRecordDownloadManifestV1(input: BuildSessionRecordDownloadManifestV1Input): SessionRecordManifestV1;
+export declare function scanSessionRecordArchiveEntriesV1(entries: readonly SessionRecordArchiveEntryForRedactionV1[]): readonly SessionRecordArchiveRedactionFindingV1[];
+export declare function assertSessionRecordArchivePublicSafeV1(entries: readonly SessionRecordArchiveEntryForRedactionV1[]): void;

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

@@ -1,29 +1,29 @@
-import { scanCustodyPayloadForSensitiveValues } from "./run-custody.js";
-export const RUN_RECORD_SCHEMA_VERSION = "aex.run-record.v1";
-export const RUN_RECORD_MANIFEST_SCHEMA_VERSION = "aex.run-record.manifest.v1";
-export class RunRecordArchiveRedactionError extends Error {
-    code = "run_record_archive_not_public_safe";
+import { scanCustodyPayloadForSensitiveValues } from "./session-custody.js";
+export const SESSION_RECORD_SCHEMA_VERSION = "aex.session-record.v1";
+export const SESSION_RECORD_MANIFEST_SCHEMA_VERSION = "aex.session-record.manifest.v1";
+export class SessionRecordArchiveRedactionError extends Error {
+    code = "session_record_archive_not_public_safe";
     findings;
     constructor(findings) {
-        super(`run record archive contains non-public data at ${formatArchiveFindingPaths(findings)}`);
-        this.name = "RunRecordArchiveRedactionError";
+        super(`session record archive contains non-public data at ${formatArchiveFindingPaths(findings)}`);
+        this.name = "SessionRecordArchiveRedactionError";
         this.findings = Object.freeze([...findings]);
     }
 }
-export function buildRunRecordDownloadManifestV1(input) {
-    const outputs = input.outputs.map((file) => normalizeArtifactSummary(file));
+export function buildSessionRecordDownloadManifestV1(input) {
+    const sessionFiles = input.sessionFiles.map((file) => normalizeArtifactSummary(file));
     const errors = (input.errors ?? []).map((error) => Object.freeze({ ...error }));
     return Object.freeze({
-        schemaVersion: RUN_RECORD_MANIFEST_SCHEMA_VERSION,
-        runRecordSchemaVersion: RUN_RECORD_SCHEMA_VERSION,
-        runId: input.runId,
+        schemaVersion: SESSION_RECORD_MANIFEST_SCHEMA_VERSION,
+        sessionRecordSchemaVersion: SESSION_RECORD_SCHEMA_VERSION,
+        sessionId: input.sessionId,
         namespaces: Object.freeze([
-            namespace("metadata", "Run metadata, submission snapshot, custody, and cost files."),
+            namespace("metadata", "SessionRecord metadata, submission snapshot, custody, and cost files."),
             namespace("events", "Typed event-channel exports."),
-            namespace("outputs", "Captured deliverables produced by the run.")
+            namespace("files", "Captured files produced by the session.")
         ]),
         files: Object.freeze([
-            file("metadata", "metadata/run.json", "run_metadata", "present"),
+            file("metadata", "metadata/session.json", "session_metadata", "present"),
             file("metadata", "metadata/submission.json", "submission_snapshot", input.submission?.status ?? "unavailable"),
             file("metadata", "metadata/cost.json", "cost", input.cost?.status ?? "pending"),
             file("metadata", "metadata/custody.json", "custody", input.custody?.status ?? "pending"),
@@ -31,9 +31,9 @@ export function buildRunRecordDownloadManifestV1(input) {
                 recordCount: input.typedEventCount ?? 0
             }),
             file("events", "events/manifest.json", "coordinator_events_manifest", input.coordinatorEventsManifest?.status ?? "unavailable"),
-            ...outputs.map((output) => artifactFile("outputs", "output", "outputs/", output))
+            ...sessionFiles.map((fileSummary) => artifactFile("files", "file", "files/", fileSummary))
         ]),
-        outputs: Object.freeze(outputs),
+        sessionFiles: Object.freeze(sessionFiles),
         errors: Object.freeze(errors)
     });
 }
@@ -74,7 +74,7 @@ function normalizeArtifactSummary(input) {
         ...(input.contentType !== undefined ? { contentType: input.contentType } : {})
     });
 }
-export function scanRunRecordArchiveEntriesV1(entries) {
+export function scanSessionRecordArchiveEntriesV1(entries) {
     const findings = [];
     for (const entry of entries) {
         if (entry.customerContent || !shouldScanArchiveEntry(entry)) {
@@ -86,14 +86,14 @@ export function scanRunRecordArchiveEntriesV1(entries) {
     }
     return Object.freeze(findings);
 }
-export function assertRunRecordArchivePublicSafeV1(entries) {
-    const findings = scanRunRecordArchiveEntriesV1(entries);
+export function assertSessionRecordArchivePublicSafeV1(entries) {
+    const findings = scanSessionRecordArchiveEntriesV1(entries);
     if (findings.length > 0) {
-        throw new RunRecordArchiveRedactionError(findings);
+        throw new SessionRecordArchiveRedactionError(findings);
     }
 }
 function shouldScanArchiveEntry(entry) {
-    if (entry.path.startsWith("outputs/")) {
+    if (entry.path.startsWith("files/")) {
         return false;
     }
     const contentType = entry.contentType?.toLowerCase() ?? "";
@@ -127,7 +127,7 @@ function isAllowedArchiveHighEntropyField(entryPath, finding) {
     if (finding.reason !== "high_entropy_token" || !entryPath.endsWith("manifest.json")) {
         return false;
     }
-    return /^\$(?:\.files\[\d+\]|\.outputs\[\d+\])\.id$/.test(finding.path);
+    return /^\$(?:\.files\[\d+\]|\.sessionFiles\[\d+\])\.id$/.test(finding.path);
 }
 function parseArchiveTextValues(path, text) {
     if (/\.json$/i.test(path)) {

package/dist/_contracts/session-retention.d.ts

@@ -0,0 +1,209 @@
+import type { SessionControlStatus } from "./status.js";
+export declare const SESSION_RETENTION_SCHEMA_VERSION = 1;
+export declare const SESSION_DELETION_MANIFEST_KIND = "aex.session_deletion_manifest.v1";
+export declare const SESSION_DELETION_JOB_KIND = "aex.session_deletion_job.v1";
+export declare const SESSION_DELETION_MANIFEST_CONTENT_TYPE = "application/json; charset=utf-8";
+export declare const SESSION_RETENTION_REDACTION_SCANNER_VERSION = 1;
+export declare const SESSION_DELETION_REASONS: readonly ["manual_delete", "retention_gc"];
+export type SessionDeletionReason = (typeof SESSION_DELETION_REASONS)[number];
+export declare const SESSION_DELETION_MANIFEST_MODES: readonly ["dry_run", "final"];
+export type SessionDeletionManifestMode = (typeof SESSION_DELETION_MANIFEST_MODES)[number];
+export declare const SESSION_DELETION_CANDIDATE_STATUSES: readonly ["selected", "blocked"];
+export type SessionDeletionCandidateStatus = (typeof SESSION_DELETION_CANDIDATE_STATUSES)[number];
+export declare const SESSION_DELETION_BLOCKERS: readonly ["non_terminal", "retention_policy_disabled", "unexpired", "held", "retention_exempt", "unresolved_cleanup", "unresolved_custody"];
+export type SessionDeletionBlocker = (typeof SESSION_DELETION_BLOCKERS)[number];
+export declare const SESSION_DELETION_COUNT_CLASSES: readonly ["object_store_objects", "files", "logs", "events", "assets", "db_event_rows", "db_file_rows", "capture_failures", "storage_samples", "custody_manifests"];
+export type SessionDeletionCountClass = (typeof SESSION_DELETION_COUNT_CLASSES)[number];
+export declare const SESSION_DELETION_COUNT_STATUSES: readonly ["counted", "not_counted", "partial", "failed"];
+export type SessionDeletionCountStatus = (typeof SESSION_DELETION_COUNT_STATUSES)[number];
+export declare const SESSION_DELETION_JOB_STATUSES: readonly ["queued", "planning", "blocked", "manifest_written", "deleting", "delete_failed", "completed", "failed"];
+export type SessionDeletionJobStatus = (typeof SESSION_DELETION_JOB_STATUSES)[number];
+export declare const SESSION_DELETION_PROOF_STATUSES: readonly ["not_started", "running", "completed", "failed"];
+export type SessionDeletionProofStatus = (typeof SESSION_DELETION_PROOF_STATUSES)[number];
+export declare const SESSION_DELETION_WRITE_STATUSES: readonly ["not_written", "written", "write_failed"];
+export type SessionDeletionWriteStatus = (typeof SESSION_DELETION_WRITE_STATUSES)[number];
+export declare const SESSION_RETENTION_EXCLUDED_VALUE_CLASSES: readonly ["raw_paths", "object_keys", "filenames", "object_sizes", "hashes", "provider_ids", "vault_ids", "resource_ids", "resource_handles", "signed_urls"];
+export type SessionRetentionExcludedValueClass = (typeof SESSION_RETENTION_EXCLUDED_VALUE_CLASSES)[number];
+export interface SessionRetentionPolicyV1 {
+    readonly mode: "retain_indefinitely" | "delete_after_days";
+    readonly manualDelete: "enabled";
+    readonly automaticDeletion: "disabled" | "enabled";
+    readonly retentionDays?: number;
+}
+export interface SessionRetentionPolicyInput {
+    readonly automaticDeletion?: boolean;
+    readonly retentionDays?: number;
+}
+export interface SessionDeletionCandidateSessionV1 {
+    readonly sessionId: string;
+    readonly workspaceId: string;
+    readonly status: SessionControlStatus | string;
+    readonly createdAt?: string;
+    readonly terminalAt?: string;
+    readonly held?: boolean;
+    readonly retentionExempt?: boolean;
+    readonly unresolvedCleanup?: boolean;
+    readonly unresolvedCustody?: boolean;
+}
+export interface SessionDeletionBlockerV1 {
+    readonly code: SessionDeletionBlocker;
+    readonly observedAt: string;
+}
+export interface SessionDeletionCandidateV1 {
+    readonly status: SessionDeletionCandidateStatus;
+    readonly reason: SessionDeletionReason;
+    readonly evaluatedAt: string;
+    readonly eligibleAt?: string;
+    readonly blockers: readonly SessionDeletionBlockerV1[];
+}
+export interface SessionDeletionCandidateInput {
+    readonly session: SessionDeletionCandidateSessionV1;
+    readonly reason: SessionDeletionReason;
+    readonly policy?: SessionRetentionPolicyV1 | SessionRetentionPolicyInput;
+    readonly now: string;
+}
+export interface SessionDeletionCountV1 {
+    readonly class: SessionDeletionCountClass | string;
+    readonly count: number;
+    readonly status: SessionDeletionCountStatus;
+    readonly countedAt?: string;
+    readonly errorClass?: string;
+}
+export interface SessionDeletionManifestSessionV1 {
+    readonly sessionId: string;
+    readonly workspaceId: string;
+    readonly status: SessionControlStatus | string;
+    readonly createdAt?: string;
+    readonly terminalAt?: string;
+    readonly eligibleAt?: string;
+}
+export interface SessionDeletionManifestRequestV1 {
+    readonly reason: SessionDeletionReason;
+    readonly actorClass: "user" | "api_key" | "system" | "operator";
+}
+export interface SessionDeletionManifestSummaryV1 {
+    readonly totalCount: number;
+    readonly failedCountClasses: number;
+    readonly partialCountClasses: number;
+    readonly blockerCount: number;
+    readonly counts: readonly SessionDeletionCountV1[];
+}
+export interface SessionDeletionManifestRedactionV1 {
+    readonly policy: "counts_status_timestamps_only";
+    readonly scannerVersion: typeof SESSION_RETENTION_REDACTION_SCANNER_VERSION;
+    readonly excludes: readonly SessionRetentionExcludedValueClass[];
+}
+export interface SessionDeletionManifestV1 {
+    readonly schemaVersion: typeof SESSION_RETENTION_SCHEMA_VERSION;
+    readonly kind: typeof SESSION_DELETION_MANIFEST_KIND;
+    readonly generatedAt: string;
+    readonly mode: SessionDeletionManifestMode;
+    readonly session: SessionDeletionManifestSessionV1;
+    readonly request: SessionDeletionManifestRequestV1;
+    readonly candidate: SessionDeletionCandidateV1;
+    readonly summary: SessionDeletionManifestSummaryV1;
+    readonly redaction: SessionDeletionManifestRedactionV1;
+}
+export interface SessionDeletionManifestInput {
+    readonly generatedAt: string;
+    readonly mode: SessionDeletionManifestMode;
+    readonly session: SessionDeletionCandidateSessionV1;
+    readonly request: SessionDeletionManifestRequestV1;
+    readonly candidate?: SessionDeletionCandidateV1;
+    readonly policy?: SessionRetentionPolicyV1 | SessionRetentionPolicyInput;
+    readonly counts?: readonly SessionDeletionCountV1[];
+}
+export interface SessionDeletionManifestProofV1 {
+    readonly status: SessionDeletionWriteStatus;
+    readonly mode?: SessionDeletionManifestMode;
+    readonly writtenAt?: string;
+}
+export interface SessionDeletionPurgeProofV1 {
+    readonly status: SessionDeletionProofStatus;
+    readonly startedAt?: string;
+    readonly completedAt?: string;
+    readonly deletedObjectCount?: number;
+}
+export interface SessionDeletionOrderProofV1 {
+    readonly manifest: SessionDeletionManifestProofV1;
+    readonly purge: SessionDeletionPurgeProofV1;
+}
+export interface SessionDeletionJobV1 {
+    readonly schemaVersion: typeof SESSION_RETENTION_SCHEMA_VERSION;
+    readonly kind: typeof SESSION_DELETION_JOB_KIND;
+    readonly jobId: string;
+    readonly sessionId: string;
+    readonly workspaceId: string;
+    readonly reason: SessionDeletionReason;
+    readonly mode: SessionDeletionManifestMode;
+    readonly status: SessionDeletionJobStatus;
+    readonly createdAt: string;
+    readonly updatedAt?: string;
+    readonly order: SessionDeletionOrderProofV1;
+    readonly candidate?: SessionDeletionCandidateV1;
+    readonly summary?: SessionDeletionManifestSummaryV1;
+}
+export interface SessionDeletionJobInput {
+    readonly jobId: string;
+    readonly sessionId: string;
+    readonly workspaceId: string;
+    readonly reason: SessionDeletionReason;
+    readonly mode: SessionDeletionManifestMode;
+    readonly status: SessionDeletionJobStatus;
+    readonly createdAt: string;
+    readonly updatedAt?: string;
+    readonly order: SessionDeletionOrderProofV1;
+    readonly candidate?: SessionDeletionCandidateV1;
+    readonly summary?: SessionDeletionManifestSummaryV1;
+}
+export interface SessionDeletionManifestWriteObject {
+    readonly sessionId: string;
+    readonly workspaceId: string;
+    readonly contentType: typeof SESSION_DELETION_MANIFEST_CONTENT_TYPE;
+    readonly manifest: SessionDeletionManifestV1;
+}
+export interface SessionDeletionManifestObjectStore {
+    putSessionDeletionManifestObject(object: SessionDeletionManifestWriteObject): Promise<void>;
+}
+export interface SessionDeletionManifestWriteResult {
+    readonly status: "written";
+    readonly schemaVersion: typeof SESSION_RETENTION_SCHEMA_VERSION;
+    readonly sessionId: string;
+    readonly workspaceId: string;
+    readonly writtenAt: string;
+    readonly mode: SessionDeletionManifestMode;
+}
+export interface SessionDeletionManifestWriter {
+    writeSessionDeletionManifest(input: SessionDeletionManifestInput): Promise<SessionDeletionManifestWriteResult>;
+}
+export type SessionRetentionRedactionReason = "forbidden_field_name" | "signed_url" | "object_store_key" | "vault_id" | "private_resource_handle" | "hash_like_value";
+export interface SessionRetentionRedactionFinding {
+    readonly path: string;
+    readonly reason: SessionRetentionRedactionReason;
+    readonly valueLength?: number;
+}
+export declare class SessionRetentionValidationError extends Error {
+    readonly code = "session_retention_contract_invalid";
+    constructor(message: string);
+}
+export declare class SessionRetentionRedactionError extends Error {
+    readonly code = "session_retention_payload_not_public_safe";
+    readonly findings: readonly SessionRetentionRedactionFinding[];
+    constructor(findings: readonly SessionRetentionRedactionFinding[]);
+}
+export declare class FakeSessionDeletionManifestObjectStore implements SessionDeletionManifestObjectStore {
+    #private;
+    putSessionDeletionManifestObject(object: SessionDeletionManifestWriteObject): Promise<void>;
+    getBySessionId(sessionId: string): SessionDeletionManifestV1 | undefined;
+    get(sessionId: string): SessionDeletionManifestV1 | undefined;
+    listSessionIds(): readonly string[];
+}
+export declare function createSessionDeletionManifestWriter(store: SessionDeletionManifestObjectStore): SessionDeletionManifestWriter;
+export declare function writeSessionDeletionManifest(store: SessionDeletionManifestObjectStore, input: SessionDeletionManifestInput): Promise<SessionDeletionManifestWriteResult>;
+export declare function buildSessionRetentionPolicy(input?: SessionRetentionPolicyInput): SessionRetentionPolicyV1;
+export declare function evaluateSessionDeletionCandidate(input: SessionDeletionCandidateInput): SessionDeletionCandidateV1;
+export declare function buildSessionDeletionManifest(input: SessionDeletionManifestInput): SessionDeletionManifestV1;
+export declare function assertSessionDeletionOrder(proof: SessionDeletionOrderProofV1): void;
+export declare function buildSessionDeletionJob(input: SessionDeletionJobInput): SessionDeletionJobV1;
+export declare function scanSessionRetentionPayloadForSensitiveValues(input: unknown): readonly SessionRetentionRedactionFinding[];
+export declare function assertPublicSafeSessionRetentionPayload(input: unknown): void;