primitive 1.23.0 → 1.24.0

package/dist/oclif/index.js

@@ -1,14 +1,15 @@
 import { A as saveActiveChatState, C as resolveCliAuth, D as deleteChatState, E as chatStatePath, M as createClient, N as createConfig, O as loadActiveChatState, S as normalizeApiBaseUrl, T as saveSignupCredentials, _ as deleteCliCredentials, a as normalizeCliEnvironmentName, b as hasStoredCliLogin, c as resolveConfigEnvironment, d as validateCliHeaderName, f as validateCliHeaderValue, g as credentialsPath, h as credentialsLockPath, i as loadCliConfig, j as PrimitiveApiClient, k as loadChatConversationByLocalId, l as saveCliConfig, m as cliAccessTokenExpiresAt, n as deleteCliConfig, o as redactCliEnvironment, p as acquireCliCredentialsLock, r as emptyCliConfig, s as removeCliEnvironment, u as upsertCliEnvironment, v as deleteCliCredentialsLock, w as saveCliCredentials, x as loadCliCredentials, y as detectPrimitiveKeyEnvMisname } from "../cli-config-BKso8oJu.js";
 import { Args, Command, Errors, Flags, ux } from "@oclif/core";
-import { chmodSync, closeSync, existsSync, fsyncSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readdirSync, renameSync, rmSync, rmdirSync, statSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
-import { createHash, randomUUID } from "node:crypto";
+import { chmodSync, closeSync, constants, existsSync, fstatSync, fsyncSync, linkSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readdirSync, renameSync, rmSync, rmdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { createHash, randomUUID, scryptSync } from "node:crypto";
 import path, { basename, dirname, join, relative, resolve, sep, win32 } from "node:path";
 import process$1 from "node:process";
 import { createInterface } from "node:readline/promises";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { execFileSync, spawn } from "node:child_process";
 import { request } from "node:http";
 import { request as request$1 } from "node:https";
-import { performance } from "node:perf_hooks";
+import { performance as performance$1 } from "node:perf_hooks";
 import { hostname } from "node:os";
 import { gunzipSync } from "node:zlib";
 import { concat, getAddress, hexToBytes, keccak256, stringToBytes } from "viem";
@@ -66,7 +67,9 @@ var sdk_gen_exports = /* @__PURE__ */ __exportAll({
 	discardEmailContent: () => discardEmailContent,
 	downloadAttachments: () => downloadAttachments,
 	downloadDomainZoneFile: () => downloadDomainZoneFile,
+	downloadEmailAttachmentPart: () => downloadEmailAttachmentPart,
 	downloadRawEmail: () => downloadRawEmail,
+	downloadSentAttachmentPart: () => downloadSentAttachmentPart,
 	getAccount: () => getAccount,
 	getAgent: () => getAgent,
 	getChallenge: () => getChallenge,
@@ -784,6 +787,49 @@ const downloadAttachments = (options) => (options.client ?? client).get({
 	...options
 });
 /**
+* Download one inbound email attachment
+*
+* Pending service release. This contract does not establish live availability.
+* Downloads the original bytes of one ordinary email attachment, selected by
+* its metadata `part_index`, not its position in an attachments array. Refresh
+* the email detail after `attachment_changed` before choosing an index again.
+* Uses bearer authentication only; signed raw-email download tokens are not accepted.
+* A paired-agent credential may read only a message addressed to its claimed address.
+* Function credentials are denied. Other bearer credentials retain their
+* existing email access boundaries. This endpoint serves email bytes only.
+*
+*/
+const downloadEmailAttachmentPart = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/emails/{id}/attachments/{part_index}",
+	...options
+});
+/**
+* Download one sent email attachment
+*
+* Pending service release. This contract does not establish live availability.
+* Downloads the original bytes of one ordinary email attachment, selected by
+* its metadata `part_index`, not its position in an attachments array. Refresh
+* the email detail after `attachment_changed` before choosing an index again.
+* Uses bearer authentication only; signed raw-email download tokens are not accepted.
+* A paired-agent credential may read only mail sent from its claimed address.
+* Receiving a copy does not authorize downloading another sender's sent content.
+* Function credentials are denied. Other bearer credentials retain their
+* existing email access boundaries. This endpoint serves email bytes only.
+*
+*/
+const downloadSentAttachmentPart = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/sent-emails/{id}/attachments/{part_index}",
+	...options
+});
+/**
 * Reply to an inbound email
 *
 * Sends an outbound reply to the inbound email identified by `id`.
@@ -3887,6 +3933,100 @@ const openapiDocument = {
 				}
 			}
 		},
+		"/emails/{id}/attachments/{part_index}": {
+			"parameters": [{ "$ref": "#/components/parameters/ResourceId" }, { "$ref": "#/components/parameters/AttachmentPartIndex" }],
+			"get": {
+				"operationId": "downloadEmailAttachmentPart",
+				"summary": "Download one inbound email attachment",
+				"description": "Pending service release. This contract does not establish live availability.\nDownloads the original bytes of one ordinary email attachment, selected by\nits metadata `part_index`, not its position in an attachments array. Refresh\nthe email detail after `attachment_changed` before choosing an index again.\nUses bearer authentication only; signed raw-email download tokens are not accepted.\nA paired-agent credential may read only a message addressed to its claimed address.\nFunction credentials are denied. Other bearer credentials retain their\nexisting email access boundaries. This endpoint serves email bytes only.\n",
+				"tags": ["Emails"],
+				"security": [{ "BearerAuth": [] }],
+				"responses": {
+					"200": { "$ref": "#/components/responses/AttachmentPart" },
+					"400": { "$ref": "#/components/responses/ValidationError" },
+					"401": { "$ref": "#/components/responses/Unauthorized" },
+					"403": { "$ref": "#/components/responses/Forbidden" },
+					"404": {
+						"description": "Missing or inaccessible message, or missing attachment part",
+						"content": { "application/json": { "schema": { "$ref": "#/components/schemas/ErrorResponse" } } }
+					},
+					"409": {
+						"description": "attachment_changed; refresh email detail before selecting a part again",
+						"content": { "application/json": { "schema": { "$ref": "#/components/schemas/ErrorResponse" } } }
+					},
+					"410": {
+						"description": "content_discarded; the original content is no longer available",
+						"content": { "application/json": { "schema": { "$ref": "#/components/schemas/ErrorResponse" } } }
+					},
+					"413": {
+						"description": "attachment_limit_exceeded; the attachment exceeds download limits",
+						"content": { "application/json": { "schema": { "$ref": "#/components/schemas/ErrorResponse" } } }
+					},
+					"502": {
+						"description": "attachment_integrity_failed; stored content failed integrity validation",
+						"content": { "application/json": { "schema": { "$ref": "#/components/schemas/ErrorResponse" } } }
+					},
+					"503": {
+						"description": "attachment_not_ready or attachment_storage_unavailable; retry after the indicated delay",
+						"headers": { "Retry-After": {
+							"description": "Delay in seconds before retrying this read",
+							"schema": {
+								"type": "integer",
+								"minimum": 0
+							}
+						} },
+						"content": { "application/json": { "schema": { "$ref": "#/components/schemas/ErrorResponse" } } }
+					}
+				}
+			}
+		},
+		"/sent-emails/{id}/attachments/{part_index}": {
+			"parameters": [{ "$ref": "#/components/parameters/ResourceId" }, { "$ref": "#/components/parameters/AttachmentPartIndex" }],
+			"get": {
+				"operationId": "downloadSentAttachmentPart",
+				"summary": "Download one sent email attachment",
+				"description": "Pending service release. This contract does not establish live availability.\nDownloads the original bytes of one ordinary email attachment, selected by\nits metadata `part_index`, not its position in an attachments array. Refresh\nthe email detail after `attachment_changed` before choosing an index again.\nUses bearer authentication only; signed raw-email download tokens are not accepted.\nA paired-agent credential may read only mail sent from its claimed address.\nReceiving a copy does not authorize downloading another sender's sent content.\nFunction credentials are denied. Other bearer credentials retain their\nexisting email access boundaries. This endpoint serves email bytes only.\n",
+				"tags": ["Sending"],
+				"security": [{ "BearerAuth": [] }],
+				"responses": {
+					"200": { "$ref": "#/components/responses/AttachmentPart" },
+					"400": { "$ref": "#/components/responses/ValidationError" },
+					"401": { "$ref": "#/components/responses/Unauthorized" },
+					"403": { "$ref": "#/components/responses/Forbidden" },
+					"404": {
+						"description": "Missing or inaccessible message, or missing attachment part",
+						"content": { "application/json": { "schema": { "$ref": "#/components/schemas/ErrorResponse" } } }
+					},
+					"409": {
+						"description": "attachment_changed; refresh email detail before selecting a part again",
+						"content": { "application/json": { "schema": { "$ref": "#/components/schemas/ErrorResponse" } } }
+					},
+					"410": {
+						"description": "content_discarded; the original content is no longer available",
+						"content": { "application/json": { "schema": { "$ref": "#/components/schemas/ErrorResponse" } } }
+					},
+					"413": {
+						"description": "attachment_limit_exceeded; the attachment exceeds download limits",
+						"content": { "application/json": { "schema": { "$ref": "#/components/schemas/ErrorResponse" } } }
+					},
+					"502": {
+						"description": "attachment_integrity_failed; stored content failed integrity validation",
+						"content": { "application/json": { "schema": { "$ref": "#/components/schemas/ErrorResponse" } } }
+					},
+					"503": {
+						"description": "attachment_not_ready or attachment_storage_unavailable; retry after the indicated delay",
+						"headers": { "Retry-After": {
+							"description": "Delay in seconds before retrying this read",
+							"schema": {
+								"type": "integer",
+								"minimum": 0
+							}
+						} },
+						"content": { "application/json": { "schema": { "$ref": "#/components/schemas/ErrorResponse" } } }
+					}
+				}
+			}
+		},
 		"/emails/{id}/reply": {
 			"parameters": [{ "$ref": "#/components/parameters/ResourceId" }],
 			"post": {
@@ -6570,6 +6710,18 @@ const openapiDocument = {
 			}
 		},
 		"parameters": {
+			"AttachmentPartIndex": {
+				"name": "part_index",
+				"in": "path",
+				"required": true,
+				"description": "The attachment metadata `part_index`, not its offset in the attachments array",
+				"schema": {
+					"type": "integer",
+					"format": "int32",
+					"minimum": 0,
+					"maximum": 2147483647
+				}
+			},
 			"ResourceId": {
 				"name": "id",
 				"in": "path",
@@ -6640,6 +6792,33 @@ const openapiDocument = {
 			}
 		},
 		"responses": {
+			"AttachmentPart": {
+				"description": "Original attachment bytes; never a JSON envelope or a base64 string",
+				"content": { "application/octet-stream": { "schema": {
+					"type": "string",
+					"format": "binary"
+				} } },
+				"headers": {
+					"X-Content-SHA256": {
+						"description": "SHA-256 hex digest of the original bytes",
+						"schema": {
+							"type": "string",
+							"pattern": "^[a-fA-F0-9]{64}$"
+						}
+					},
+					"Content-Disposition": {
+						"description": "Safe attachment disposition with a sanitized filename",
+						"schema": { "type": "string" }
+					},
+					"Cache-Control": {
+						"description": "Attachment responses are private and must not be stored by caches",
+						"schema": {
+							"type": "string",
+							"example": "private, no-store"
+						}
+					}
+				}
+			},
 			"PullContentGone": {
 				"description": "Queued content is no longer available",
 				"content": { "application/json": { "schema": { "$ref": "#/components/schemas/ErrorResponse" } } }
@@ -7658,6 +7837,12 @@ const openapiDocument = {
 									"conflict",
 									"mx_conflict",
 									"not_scheduled",
+									"attachment_changed",
+									"content_discarded",
+									"attachment_limit_exceeded",
+									"attachment_integrity_failed",
+									"attachment_not_ready",
+									"attachment_storage_unavailable",
 									"outbound_disabled",
 									"cannot_send_from_domain",
 									"recipient_not_allowed",
@@ -10467,6 +10652,53 @@ const openapiDocument = {
 						"body_html": {
 							"type": ["string", "null"],
 							"description": "HTML body sent on the wire. Null when the send\ncarried only a plain-text body, or when bodies\nhave been discarded post-send.\n"
+						},
+						"attachments": {
+							"type": "array",
+							"description": "Metadata for submitted inline attachments; download availability is reported separately. Metadata may exist when the archive is unavailable, and legacy sends may have no metadata. Offloaded payload files are not included in the inline archive.",
+							"items": {
+								"type": "object",
+								"description": "Metadata for one submitted inline attachment.",
+								"additionalProperties": true,
+								"properties": {
+									"filename": { "type": ["string", "null"] },
+									"content_type": { "type": "string" },
+									"size_bytes": {
+										"type": "integer",
+										"minimum": 0,
+										"maximum": 9007199254740991
+									},
+									"sha256": { "type": "string" },
+									"part_index": {
+										"type": "integer",
+										"minimum": 0,
+										"maximum": 9007199254740991
+									},
+									"tar_path": { "type": "string" }
+								},
+								"required": [
+									"filename",
+									"content_type",
+									"size_bytes",
+									"sha256",
+									"part_index",
+									"tar_path"
+								]
+							}
+						},
+						"attachments_size_bytes": {
+							"type": "integer",
+							"minimum": 0,
+							"maximum": 9007199254740991,
+							"description": "Original decoded attachment byte total accepted for this send, not the compressed archive size. It may exceed the retained inline total after offloading."
+						},
+						"attachments_complete": {
+							"type": "boolean",
+							"description": "Whether attachments enumerates the complete original submitted attachment set, including zero-byte and inline CID parts. True requires no submitted payload-reference, offloaded, or visibility-filtered attachment to be omitted, retained content, and a published archive when the attachment inventory is nonempty. False or absent provides no completeness proof, including for legacy or discarded content. This field grants no download access and has no interaction semantics."
+						},
+						"attachments_download_available": {
+							"type": "boolean",
+							"description": "Whether an inline attachment archive has been successfully retained and is available for download. Download authorization is checked separately; address-bound agent connection keys cannot download archives."
 						}
 					}
 				}]
@@ -16256,6 +16488,38 @@ const operationManifest = [
 		"tag": "Emails",
 		"tagCommand": "emails"
 	},
+	{
+		"binaryResponse": true,
+		"bodyRequired": false,
+		"command": "download-email-attachment-part",
+		"description": "Pending service release. This contract does not establish live availability.\nDownloads the original bytes of one ordinary email attachment, selected by\nits metadata `part_index`, not its position in an attachments array. Refresh\nthe email detail after `attachment_changed` before choosing an index again.\nUses bearer authentication only; signed raw-email download tokens are not accepted.\nA paired-agent credential may read only a message addressed to its claimed address.\nFunction credentials are denied. Other bearer credentials retain their\nexisting email access boundaries. This endpoint serves email bytes only.\n",
+		"hasJsonBody": false,
+		"method": "GET",
+		"operationId": "downloadEmailAttachmentPart",
+		"path": "/emails/{id}/attachments/{part_index}",
+		"pathParams": [{
+			"description": "Resource UUID",
+			"enum": null,
+			"name": "id",
+			"required": true,
+			"type": "string"
+		}, {
+			"description": "The attachment metadata `part_index`, not its offset in the attachments array",
+			"enum": null,
+			"maximum": 2147483647,
+			"minimum": 0,
+			"name": "part_index",
+			"required": true,
+			"type": "integer"
+		}],
+		"queryParams": [],
+		"requestSchema": null,
+		"responseSchema": null,
+		"sdkName": "downloadEmailAttachmentPart",
+		"summary": "Download one inbound email attachment",
+		"tag": "Emails",
+		"tagCommand": "emails"
+	},
 	{
 		"binaryResponse": true,
 		"bodyRequired": false,
@@ -23742,6 +24006,53 @@ const operationManifest = [
 					"body_html": {
 						"type": ["string", "null"],
 						"description": "HTML body sent on the wire. Null when the send\ncarried only a plain-text body, or when bodies\nhave been discarded post-send.\n"
+					},
+					"attachments": {
+						"type": "array",
+						"description": "Metadata for submitted inline attachments; download availability is reported separately. Metadata may exist when the archive is unavailable, and legacy sends may have no metadata. Offloaded payload files are not included in the inline archive.",
+						"items": {
+							"type": "object",
+							"description": "Metadata for one submitted inline attachment.",
+							"additionalProperties": true,
+							"properties": {
+								"filename": { "type": ["string", "null"] },
+								"content_type": { "type": "string" },
+								"size_bytes": {
+									"type": "integer",
+									"minimum": 0,
+									"maximum": 9007199254740991
+								},
+								"sha256": { "type": "string" },
+								"part_index": {
+									"type": "integer",
+									"minimum": 0,
+									"maximum": 9007199254740991
+								},
+								"tar_path": { "type": "string" }
+							},
+							"required": [
+								"filename",
+								"content_type",
+								"size_bytes",
+								"sha256",
+								"part_index",
+								"tar_path"
+							]
+						}
+					},
+					"attachments_size_bytes": {
+						"type": "integer",
+						"minimum": 0,
+						"maximum": 9007199254740991,
+						"description": "Original decoded attachment byte total accepted for this send, not the compressed archive size. It may exceed the retained inline total after offloading."
+					},
+					"attachments_complete": {
+						"type": "boolean",
+						"description": "Whether attachments enumerates the complete original submitted attachment set, including zero-byte and inline CID parts. True requires no submitted payload-reference, offloaded, or visibility-filtered attachment to be omitted, retained content, and a published archive when the attachment inventory is nonempty. False or absent provides no completeness proof, including for legacy or discarded content. This field grants no download access and has no interaction semantics."
+					},
+					"attachments_download_available": {
+						"type": "boolean",
+						"description": "Whether an inline attachment archive has been successfully retained and is available for download. Download authorization is checked separately; address-bound agent connection keys cannot download archives."
 					}
 				}
 			}]
@@ -23751,6 +24062,38 @@ const operationManifest = [
 		"tag": "Sending",
 		"tagCommand": "sending"
 	},
+	{
+		"binaryResponse": true,
+		"bodyRequired": false,
+		"command": "download-sent-attachment-part",
+		"description": "Pending service release. This contract does not establish live availability.\nDownloads the original bytes of one ordinary email attachment, selected by\nits metadata `part_index`, not its position in an attachments array. Refresh\nthe email detail after `attachment_changed` before choosing an index again.\nUses bearer authentication only; signed raw-email download tokens are not accepted.\nA paired-agent credential may read only mail sent from its claimed address.\nReceiving a copy does not authorize downloading another sender's sent content.\nFunction credentials are denied. Other bearer credentials retain their\nexisting email access boundaries. This endpoint serves email bytes only.\n",
+		"hasJsonBody": false,
+		"method": "GET",
+		"operationId": "downloadSentAttachmentPart",
+		"path": "/sent-emails/{id}/attachments/{part_index}",
+		"pathParams": [{
+			"description": "Resource UUID",
+			"enum": null,
+			"name": "id",
+			"required": true,
+			"type": "string"
+		}, {
+			"description": "The attachment metadata `part_index`, not its offset in the attachments array",
+			"enum": null,
+			"maximum": 2147483647,
+			"minimum": 0,
+			"name": "part_index",
+			"required": true,
+			"type": "integer"
+		}],
+		"queryParams": [],
+		"requestSchema": null,
+		"responseSchema": null,
+		"sdkName": "downloadSentAttachmentPart",
+		"summary": "Download one sent email attachment",
+		"tag": "Sending",
+		"tagCommand": "sending"
+	},
 	{
 		"binaryResponse": false,
 		"bodyRequired": false,
@@ -24219,6 +24562,53 @@ const operationManifest = [
 					"body_html": {
 						"type": ["string", "null"],
 						"description": "HTML body sent on the wire. Null when the send\ncarried only a plain-text body, or when bodies\nhave been discarded post-send.\n"
+					},
+					"attachments": {
+						"type": "array",
+						"description": "Metadata for submitted inline attachments; download availability is reported separately. Metadata may exist when the archive is unavailable, and legacy sends may have no metadata. Offloaded payload files are not included in the inline archive.",
+						"items": {
+							"type": "object",
+							"description": "Metadata for one submitted inline attachment.",
+							"additionalProperties": true,
+							"properties": {
+								"filename": { "type": ["string", "null"] },
+								"content_type": { "type": "string" },
+								"size_bytes": {
+									"type": "integer",
+									"minimum": 0,
+									"maximum": 9007199254740991
+								},
+								"sha256": { "type": "string" },
+								"part_index": {
+									"type": "integer",
+									"minimum": 0,
+									"maximum": 9007199254740991
+								},
+								"tar_path": { "type": "string" }
+							},
+							"required": [
+								"filename",
+								"content_type",
+								"size_bytes",
+								"sha256",
+								"part_index",
+								"tar_path"
+							]
+						}
+					},
+					"attachments_size_bytes": {
+						"type": "integer",
+						"minimum": 0,
+						"maximum": 9007199254740991,
+						"description": "Original decoded attachment byte total accepted for this send, not the compressed archive size. It may exceed the retained inline total after offloading."
+					},
+					"attachments_complete": {
+						"type": "boolean",
+						"description": "Whether attachments enumerates the complete original submitted attachment set, including zero-byte and inline CID parts. True requires no submitted payload-reference, offloaded, or visibility-filtered attachment to be omitted, retained content, and a published archive when the attachment inventory is nonempty. False or absent provides no completeness proof, including for legacy or discarded content. This field grants no download access and has no interaction semantics."
+					},
+					"attachments_download_available": {
+						"type": "boolean",
+						"description": "Whether an inline attachment archive has been successfully retained and is available for download. Download authorization is checked separately; address-bound agent connection keys cannot download archives."
 					}
 				}
 			}]
@@ -24943,6 +25333,53 @@ const operationManifest = [
 					"body_html": {
 						"type": ["string", "null"],
 						"description": "HTML body sent on the wire. Null when the send\ncarried only a plain-text body, or when bodies\nhave been discarded post-send.\n"
+					},
+					"attachments": {
+						"type": "array",
+						"description": "Metadata for submitted inline attachments; download availability is reported separately. Metadata may exist when the archive is unavailable, and legacy sends may have no metadata. Offloaded payload files are not included in the inline archive.",
+						"items": {
+							"type": "object",
+							"description": "Metadata for one submitted inline attachment.",
+							"additionalProperties": true,
+							"properties": {
+								"filename": { "type": ["string", "null"] },
+								"content_type": { "type": "string" },
+								"size_bytes": {
+									"type": "integer",
+									"minimum": 0,
+									"maximum": 9007199254740991
+								},
+								"sha256": { "type": "string" },
+								"part_index": {
+									"type": "integer",
+									"minimum": 0,
+									"maximum": 9007199254740991
+								},
+								"tar_path": { "type": "string" }
+							},
+							"required": [
+								"filename",
+								"content_type",
+								"size_bytes",
+								"sha256",
+								"part_index",
+								"tar_path"
+							]
+						}
+					},
+					"attachments_size_bytes": {
+						"type": "integer",
+						"minimum": 0,
+						"maximum": 9007199254740991,
+						"description": "Original decoded attachment byte total accepted for this send, not the compressed archive size. It may exceed the retained inline total after offloading."
+					},
+					"attachments_complete": {
+						"type": "boolean",
+						"description": "Whether attachments enumerates the complete original submitted attachment set, including zero-byte and inline CID parts. True requires no submitted payload-reference, offloaded, or visibility-filtered attachment to be omitted, retained content, and a published archive when the attachment inventory is nonempty. False or absent provides no completeness proof, including for legacy or discarded content. This field grants no download access and has no interaction semantics."
+					},
+					"attachments_download_available": {
+						"type": "boolean",
+						"description": "Whether an inline attachment archive has been successfully retained and is available for download. Download authorization is checked separately; address-bound agent connection keys cannot download archives."
 					}
 				}
 			}]
@@ -27828,60 +28265,54 @@ function readAttachmentFiles(paths, readFile = readFileSync) {
 //#endregion
 //#region src/oclif/chat-lock.ts
 /**
-* Filesystem mutex around the chat-state read → POST → save sequence.
-*
-* Why this exists. The chat reply flow is read-modify-write across an
-* RTT to the API: `loadActiveChatState` → `replyToEmail` → poll → save.
-* Two concurrent invocations (e.g. the user re-runs `primitive chat
-* reply` before the first cycle finishes its 5–12 s poll) read the
-* same stale `last_reply_email_id` and POST to it, producing a
-* duplicate /v1/emails/{id}/reply that the server deduplicates by
-* content_hash. The second invocation then polls forever for a reply
-* that arrived in response to the *first* send and has already been
-* surfaced by the *first* invocation.
-*
-* The lock is per-process-config-dir, not per-conversation: holding it
-* for a few seconds while one chat reply completes is a reasonable UX
-* constraint and clearly explained on contention. The lock is
-* re-entrant within a single Node process (ChatReplyCommand wraps
-* ChatCommand internally), but rejects cross-process contention.
-*
-* Liveness. The lock file stores the holder's PID. On EEXIST we probe
-* the holder with `process.kill(pid, 0)`; if the holder is gone (e.g.
-* a previous chat invocation crashed without releasing), we steal the
-* lock. This avoids needing a heartbeat or mtime-based stale check,
-* either of which has its own race surface.
-*
-* Releases. The returned function is idempotent. Callers must call it
-* in a finally block. We also register process-exit / signal handlers
-* so a Ctrl-C during the poll loop still cleans up.
+* Conversation locks cover one request/reply cycle. The default lock retains
+* its historical filename and protects short shared chat-state transactions.
+* Scope names are hashed so addresses and other identifiers stay out of paths.
 */
 const LOCK_FILENAME = "chat-state.lock";
-let processHolder = null;
-/**
-* Whether we've installed our exit / signal listeners on the
-* `process` object. Done lazily on first acquire and never undone:
-* adding handlers per-acquire would let them accumulate (each
-* acquire registers four listeners, and `process.once` can't be
-* un-once'd), which is harmless in production but produces
-* `MaxListenersExceededWarning` + cascading no-op fires in tests
-* that acquire/release across many `it()` blocks. Greptile P2.
-*
-* The handlers consult the current `processHolder` and act only if
-* a lock is actually held, so leaving them installed across
-* release boundaries is safe: a released or never-acquired lock
-* makes them no-ops.
-*/
+const STATE_LOCK_TIMEOUT_MS = 5e3;
+const STATE_LOCK_RETRY_MS = 25;
+const processHolders = /* @__PURE__ */ new Map();
 let exitListenersInstalled = false;
+function lockPath(configDir, scope) {
+	const name = scope === void 0 ? LOCK_FILENAME : `chat-${createHash("sha256").update(scope).digest("hex")}.lock`;
+	return join(resolve(configDir), name);
+}
+function readSnapshot(path) {
+	let fd;
+	try {
+		if (!lstatSync(path).isFile()) return null;
+		fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	}
+	try {
+		const stat = fstatSync(fd);
+		return {
+			device: stat.dev,
+			inode: stat.ino,
+			contents: stat.size <= 128 ? readFileSync(fd, "utf8") : ""
+		};
+	} finally {
+		closeSync(fd);
+	}
+}
+function matchesSnapshot(path, snapshot) {
+	const current = readSnapshot(path);
+	return current !== null && current.device === snapshot.device && current.inode === snapshot.inode && current.contents === snapshot.contents;
+}
+function removeOwnedLock(holder) {
+	try {
+		if (matchesSnapshot(holder.path, holder)) unlinkSync(holder.path);
+	} catch {}
+}
 function installExitListenersOnce() {
 	if (exitListenersInstalled) return;
 	exitListenersInstalled = true;
 	const cleanup = () => {
-		if (processHolder === null) return;
-		try {
-			unlinkSync(lockPath(processHolder.configDir));
-		} catch {}
-		processHolder = null;
+		for (const holder of processHolders.values()) removeOwnedLock(holder);
+		processHolders.clear();
 	};
 	process.on("exit", cleanup);
 	for (const signal of [
@@ -27897,100 +28328,218 @@ function installExitListenersOnce() {
 		process.on(signal, handler);
 	}
 }
-function lockPath(configDir) {
-	return join(configDir, LOCK_FILENAME);
-}
-/**
-* `process.kill(pid, 0)` returns true if the process exists and we
-* have permission to signal it. Throws ESRCH when the pid is gone,
-* EPERM if it exists but isn't ours. Both "exists" cases mean we
-* should NOT steal the lock; only ESRCH proves the holder is dead.
-*/
 function pidIsAlive(pid) {
 	try {
 		process.kill(pid, 0);
 		return true;
-	} catch (err) {
-		if (err.code === "ESRCH") return false;
-		return true;
+	} catch (error) {
+		return error.code !== "ESRCH";
 	}
 }
-function readHolderPid(configDir) {
-	try {
-		const raw = readFileSync(lockPath(configDir), "utf8").trim();
-		const pid = Number.parseInt(raw, 10);
-		return Number.isFinite(pid) && pid > 0 ? pid : null;
-	} catch {
-		return null;
+function holderPid(snapshot) {
+	const lines = snapshot?.contents.trim().split("\n");
+	if (!lines || lines.length > 2 || !/^[1-9]\d*$/.test(lines[0] ?? "")) return null;
+	if (lines.length === 2 && !/^[0-9a-f-]{36}$/.test(lines[1] ?? "")) return null;
+	const pid = Number(lines[0]);
+	return Number.isSafeInteger(pid) && pid > 0 ? pid : null;
+}
+function reclaimStaleLock(path, previous, temporary, contender) {
+	const guards = [];
+	const visited = /* @__PURE__ */ new Set();
+	let target = previous;
+	for (;;) {
+		const guardPath = `${path}.reclaim-${createHash("sha256").update(`${target.device}:${target.inode}:${target.contents}`).digest("hex")}`;
+		if (visited.has(guardPath)) throw new ChatLockContentionError(0);
+		visited.add(guardPath);
+		try {
+			linkSync(temporary, guardPath);
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+			const guard = readSnapshot(guardPath);
+			const pid = holderPid(guard);
+			if (!guard || pid === null || pidIsAlive(pid)) throw new ChatLockContentionError(pid ?? 0);
+			guards.push({
+				path: guardPath,
+				snapshot: guard
+			});
+			target = guard;
+			continue;
+		}
+		guards.push({
+			path: guardPath,
+			snapshot: contender
+		});
+		let removed = false;
+		try {
+			const pid = holderPid(previous);
+			if (matchesSnapshot(path, previous) && pid !== null && !pidIsAlive(pid)) unlinkSync(path);
+			removed = !matchesSnapshot(path, previous);
+		} finally {
+			if (removed) for (const guard of guards) try {
+				if (matchesSnapshot(guard.path, guard.snapshot)) unlinkSync(guard.path);
+			} catch {}
+		}
+		return;
 	}
 }
 var ChatLockContentionError = class extends Error {
 	constructor(holderPid) {
-		super(`Another \`primitive chat\` invocation (pid ${holderPid}) is in progress. Wait for it to finish, or kill it before retrying.`);
+		super(holderPid > 0 ? `Another \`primitive chat\` invocation (pid ${holderPid}) is in progress. Wait for it to finish, or kill it before retrying.` : "The chat lock holder could not be verified. Retry after the current invocation finishes.");
 		this.holderPid = holderPid;
 		this.name = "ChatLockContentionError";
 	}
 };
-/**
-* Acquire the chat-state mutex for this configDir. Returns a release
-* function that is safe to call any number of times. Throws
-* `ChatLockContentionError` if another live process holds the lock.
-*/
-function acquireChatLock(configDir) {
-	if (processHolder?.configDir === configDir) {
-		processHolder.depth += 1;
-		let released = false;
-		return () => {
-			if (released) return;
-			released = true;
-			if (processHolder !== null) processHolder.depth -= 1;
-		};
+function releaseHolder(holder) {
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		if (processHolders.get(holder.path) !== holder) return;
+		holder.depth -= 1;
+		if (holder.depth === 0) {
+			removeOwnedLock(holder);
+			processHolders.delete(holder.path);
+		}
+	};
+}
+/** Acquire synchronously; the same scope is reentrant within this process. */
+function acquireChatLock(configDir, scope) {
+	const path = lockPath(configDir, scope);
+	const held = processHolders.get(path);
+	if (held) {
+		if (!matchesSnapshot(path, held)) throw new ChatLockContentionError(0);
+		held.depth += 1;
+		return releaseHolder(held);
 	}
-	mkdirSync(configDir, {
+	mkdirSync(resolve(configDir), {
 		mode: 448,
 		recursive: true
 	});
-	for (let attempt = 0; attempt < 2; attempt++) {
-		let fd;
+	const contents = `${process.pid}\n${randomUUID()}\n`;
+	const temporary = `${path}.${randomUUID()}.tmp`;
+	const fd = openSync(temporary, "wx", 384);
+	let snapshot;
+	try {
+		writeFileSync(fd, contents);
+		const stat = fstatSync(fd);
+		snapshot = {
+			device: stat.dev,
+			inode: stat.ino,
+			contents
+		};
+	} catch (error) {
+		closeSync(fd);
+		unlinkSync(temporary);
+		throw error;
+	}
+	closeSync(fd);
+	const publish = () => {
 		try {
-			fd = openSync(lockPath(configDir), "wx", 384);
-		} catch (err) {
-			if (err.code !== "EEXIST") throw err;
-			const holder = readHolderPid(configDir);
-			if (holder === null || !pidIsAlive(holder)) {
-				try {
-					unlinkSync(lockPath(configDir));
-				} catch (unlinkErr) {
-					if (unlinkErr.code !== "ENOENT") throw unlinkErr;
-				}
-				continue;
-			}
-			throw new ChatLockContentionError(holder);
+			linkSync(temporary, path);
+			return true;
+		} catch (error) {
+			if (error.code === "EEXIST") return false;
+			throw error;
 		}
-		writeSync(fd, `${process.pid}\n`);
-		closeSync(fd);
-		processHolder = {
-			configDir,
+	};
+	try {
+		let acquired = publish();
+		if (!acquired) {
+			const previous = readSnapshot(path);
+			const pid = holderPid(previous);
+			if (!previous || pid === null || pidIsAlive(pid)) throw new ChatLockContentionError(pid ?? 0);
+			reclaimStaleLock(path, previous, temporary, snapshot);
+			acquired = publish();
+			if (!acquired) throw new ChatLockContentionError(holderPid(readSnapshot(path)) ?? 0);
+		}
+		const holder = {
+			...snapshot,
+			path,
 			depth: 1
 		};
+		processHolders.set(path, holder);
 		installExitListenersOnce();
-		let released = false;
-		return () => {
-			if (released) return;
-			released = true;
-			if (processHolder?.configDir === configDir) {
-				processHolder.depth -= 1;
-				if (processHolder.depth <= 0) {
-					try {
-						unlinkSync(lockPath(configDir));
-					} catch {}
-					processHolder = null;
-				}
-			}
+		return releaseHolder(holder);
+	} finally {
+		try {
+			unlinkSync(temporary);
+		} catch {}
+	}
+}
+/**
+* Serialize short state transactions, including independent callers in this
+* process. Do not nest this API or hold its release function across network IO.
+*/
+async function acquireChatStateLock(configDir) {
+	const deadline = performance.now() + STATE_LOCK_TIMEOUT_MS;
+	const path = lockPath(configDir);
+	for (;;) try {
+		if (processHolders.has(path)) throw new ChatLockContentionError(process.pid);
+		return acquireChatLock(configDir);
+	} catch (error) {
+		if (!(error instanceof ChatLockContentionError)) throw error;
+		const remaining = deadline - performance.now();
+		if (remaining <= 0) throw error;
+		await setTimeout$1(Math.min(STATE_LOCK_RETRY_MS, remaining));
+	}
+}
+//#endregion
+//#region src/oclif/chat-receipt.ts
+/** Keep API credentials out of request fingerprints, including low-entropy local keys. */
+function chatCredentialIdentity(key, apiOrigin) {
+	return key === void 0 ? void 0 : scryptSync(key, apiOrigin, 32).toString("hex");
+}
+function chatRequestHash(value) {
+	return createHash("sha256").update(JSON.stringify(value)).digest("hex");
+}
+function saveChatReceipt(receipt) {
+	const temporary = `${receipt.path}.${process.pid}.${randomUUID()}.tmp`;
+	try {
+		writeFileSync(temporary, `${JSON.stringify(receipt.data)}\n`, { mode: 384 });
+		renameSync(temporary, receipt.path);
+	} finally {
+		rmSync(temporary, { force: true });
+	}
+}
+function parseReceipt(raw) {
+	const value = JSON.parse(raw);
+	if (!value || value.version !== 1 || typeof value.request_hash !== "string" || typeof value.sent_at !== "string" || !Number.isFinite(Date.parse(value.sent_at)) || typeof value.completed !== "boolean" || value.sent !== null && (!value.sent || typeof value.sent.id !== "string" || !value.sent.id || typeof value.sent.status !== "string")) throw new Error("Invalid chat receipt");
+	return value;
+}
+/** Caller holds the request/parent lock until completion. Unknown POSTs never retry. */
+function beginChatReceipt(configDir, scope, requestHash) {
+	const directory = join(configDir, "chat-receipts");
+	mkdirSync(directory, {
+		recursive: true,
+		mode: 448
+	});
+	const path = join(directory, `${chatRequestHash(scope)}.json`);
+	let previous;
+	try {
+		previous = parseReceipt(readFileSync(path, "utf8"));
+	} catch (error) {
+		if (error.code !== "ENOENT") throw new Error(`Cannot safely read chat receipt ${path}. Inspect it and sent history before retrying.`, { cause: error });
+	}
+	if (previous && !previous.completed) {
+		if (previous.sent === null) throw new Error(`A previous send has an uncertain outcome. Inspect sent history before sending again. Receipt: ${path}`);
+		if (previous.request_hash !== requestHash) throw new Error(`This reply still awaits a response to sent email ${previous.sent.id}. Retry the same message to resume, or inspect that send. Receipt: ${path}`);
+		return {
+			path,
+			data: previous
 		};
 	}
-	/* v8 ignore next 4 -- the for-loop returns or throws on every iteration; the unreachable trailer keeps TS happy. */
-	throw new Error("acquireChatLock: exhausted retries (this is a bug — should not be reachable)");
+	const receipt = {
+		path,
+		data: {
+			version: 1,
+			request_hash: requestHash,
+			sent_at: (/* @__PURE__ */ new Date()).toISOString(),
+			sent: null,
+			completed: false
+		}
+	};
+	saveChatReceipt(receipt);
+	return receipt;
 }
 //#endregion
 //#region src/oclif/outbound-defaults.ts
@@ -28465,7 +29014,8 @@ function buildChatJsonEnvelope(context) {
 		follow_up_commands: buildChatFollowUpCommands(context)
 	};
 }
-function persistActiveChat(params) {
+async function persistActiveChat(params) {
+	const release = await acquireChatStateLock(params.configDir);
 	try {
 		return saveActiveChatState(params.configDir, {
 			from: params.context.from,
@@ -28482,6 +29032,8 @@ function persistActiveChat(params) {
 		const detail = error instanceof Error ? error.message : String(error);
 		params.writeWarning?.(`Warning: could not save local chat state: ${detail}\n`);
 		return null;
+	} finally {
+		release();
 	}
 }
 /**
@@ -28636,7 +29188,12 @@ var ChatCommand = class ChatCommand extends Command {
   is less exact than strict matching. Use --strict-only when matching
   the wrong reply is worse than timing out. Progress is written to
   stderr while the CLI waits. Exits non-zero on timeout and prints
-  recovery commands when the send succeeded but no reply was returned.`;
+  recovery commands when the send succeeded but no reply was returned.
+
+  Independent addressed chats can run concurrently. Replies reserve their
+  selected local chat. The last successfully saved reply becomes active.
+  Retrying an interrupted or timed-out request resumes its recorded send;
+  an uncertain send outcome requires inspection instead of a blind resend.`;
 	static summary = "Chat with an agent over email (send and wait for the reply)";
 	static examples = [
 		"<%= config.bin %> chat help@agent.acme.dev 'how do I rotate my API key?'",
@@ -28721,12 +29278,6 @@ var ChatCommand = class ChatCommand extends Command {
 		if (!message.trim()) throw cliError$6(replyMode ? "Reply body is empty." : "Message body is empty.");
 		await runWithTiming(flags.time, async () => {
 			let releaseLock;
-			try {
-				releaseLock = acquireChatLock(this.config.configDir);
-			} catch (err) {
-				if (err instanceof ChatLockContentionError) throw cliError$6(err.message);
-				throw err;
-			}
 			try {
 				const { apiClient, auth, baseUrlOverridden } = await createAuthenticatedCliApiClient({
 					apiKey: flags["api-key"],
@@ -28792,10 +29343,46 @@ var ChatCommand = class ChatCommand extends Command {
 					from = flags.from ?? await pickDefaultFromAddress(apiClient, authFailureContext);
 					subject = flags.subject ?? deriveSubject(message);
 				}
-				const sentAtIso = (/* @__PURE__ */ new Date()).toISOString();
-				if (replyMode) progress?.update(`Sending reply to ${args.recipient}`);
+				const requestHash = chatRequestHash({
+					api: auth.apiBaseUrl,
+					account: auth.credentials?.org_id ?? chatCredentialIdentity(auth.apiKey, auth.apiBaseUrl),
+					from,
+					recipient: args.recipient,
+					subject,
+					message,
+					parent: parentReply?.id ?? flags["in-reply-to"],
+					attachments
+				});
+				const scope = parentReply ? chatRequestHash({
+					api: auth.apiBaseUrl,
+					from,
+					parent: parentReply.id
+				}) : requestHash;
+				try {
+					releaseLock = acquireChatLock(this.config.configDir, scope);
+				} catch (error) {
+					if (error instanceof ChatLockContentionError) throw cliError$6(error.message);
+					throw error;
+				}
+				if (flags["chat-local-id"] !== void 0) {
+					const releaseState = await acquireChatStateLock(this.config.configDir);
+					try {
+						const current = loadChatConversationByLocalId(this.config.configDir, flags["chat-local-id"]);
+						if (!current || current.last_reply_email_id !== parentReply?.id) throw cliError$6("This local chat advanced while preparing the reply. Retry to use its latest reply.");
+					} finally {
+						releaseState();
+					}
+				}
+				const receipt = beginChatReceipt(this.config.configDir, scope, requestHash);
+				const sentAtIso = receipt.data.sent_at;
+				process.stderr.write(`Chat receipt: ${receipt.path}\n`);
+				if (receipt.data.sent !== null) progress?.start("Resuming the recorded send without sending again");
+				else if (replyMode) progress?.update(`Sending reply to ${args.recipient}`);
 				else progress?.start(`Sending message to ${args.recipient}`);
-				const sendResult = parentReply !== void 0 ? await replyToEmail({
+				const sendResult = receipt.data.sent !== null ? {
+					data: { data: receipt.data.sent },
+					error: void 0
+				} : parentReply !== void 0 ? await replyToEmail({
 					body: {
 						body_text: message,
 						from,
@@ -28817,6 +29404,20 @@ var ChatCommand = class ChatCommand extends Command {
 					responseStyle: "fields"
 				});
 				if (sendResult.error) {
+					const status = "response" in sendResult ? sendResult.response?.status : void 0;
+					if (status !== void 0 && [
+						400,
+						401,
+						402,
+						403,
+						404,
+						413,
+						422,
+						429
+					].includes(status)) {
+						receipt.data.completed = true;
+						saveChatReceipt(receipt);
+					}
 					progress?.fail(replyMode ? "Reply send failed." : "Message send failed.");
 					const errorPayload = extractErrorPayload(sendResult.error);
 					writeErrorWithHints(errorPayload);
@@ -28832,6 +29433,8 @@ var ChatCommand = class ChatCommand extends Command {
 					progress?.fail("Send succeeded but the API returned no data.");
 					throw cliError$6("Send succeeded but the API returned no data.");
 				}
+				receipt.data.sent = sent;
+				saveChatReceipt(receipt);
 				const replyAddress = sent.from || from;
 				const baseContext = {
 					from: replyAddress,
@@ -28878,7 +29481,7 @@ var ChatCommand = class ChatCommand extends Command {
 							matchStrategy: "strict",
 							reply: detail
 						};
-						const localChatId = persistActiveChat({
+						const localChatId = await persistActiveChat({
 							configDir: this.config.configDir,
 							context: outputContext,
 							preferredLocalId: flags["chat-local-id"],
@@ -28888,6 +29491,8 @@ var ChatCommand = class ChatCommand extends Command {
 							...outputContext,
 							localChatId
 						};
+						receipt.data.completed = localChatId !== null;
+						saveChatReceipt(receipt);
 						if (flags.json) this.log(JSON.stringify(buildChatJsonEnvelope(outputContext), null, 2));
 						else this.log(formatChatResponse(outputContext));
 						return;
@@ -28942,7 +29547,7 @@ var ChatCommand = class ChatCommand extends Command {
 					matchStrategy: replyResult.matchStrategy,
 					reply: replyResult.reply
 				};
-				const localChatId = persistActiveChat({
+				const localChatId = await persistActiveChat({
 					configDir: this.config.configDir,
 					context: outputContext,
 					preferredLocalId: flags["chat-local-id"],
@@ -28952,10 +29557,12 @@ var ChatCommand = class ChatCommand extends Command {
 					...outputContext,
 					localChatId
 				};
+				receipt.data.completed = localChatId !== null;
+				saveChatReceipt(receipt);
 				if (flags.json) this.log(JSON.stringify(buildChatJsonEnvelope(outputContext), null, 2));
 				else this.log(formatChatResponse(outputContext));
 			} finally {
-				releaseLock();
+				releaseLock?.();
 			}
 		});
 	}
@@ -29035,15 +29642,19 @@ var ChatReplyCommand = class ChatReplyCommand extends Command {
 		if (flags.id === void 0 && args.message !== void 0 && positionalLocalId === null) throw cliError$6("When passing two positional arguments to `primitive chat reply`, the first must be a local chat id. Use `primitive chat reply '<message>'` for the active chat or `primitive chat reply --id <id> '<message>'` for a specific chat.");
 		if (flags.id !== void 0 && args.message !== void 0) throw cliError$6("With --id, pass the reply body as a single positional argument or pipe it via stdin.");
 		let release;
-		try {
-			release = acquireChatLock(this.config.configDir);
-		} catch (err) {
-			if (err instanceof ChatLockContentionError) throw cliError$6(err.message);
-			throw err;
-		}
 		try {
 			const localId = flags.id ?? (typeof positionalLocalId === "number" ? positionalLocalId : void 0);
-			const state = localId === void 0 ? loadActiveChatState(this.config.configDir) : loadChatConversationByLocalId(this.config.configDir, localId);
+			const releaseState = await acquireChatStateLock(this.config.configDir);
+			let state;
+			try {
+				state = localId === void 0 ? loadActiveChatState(this.config.configDir) : loadChatConversationByLocalId(this.config.configDir, localId);
+				if (state) release = acquireChatLock(this.config.configDir, `local:${state.local_id}`);
+			} catch (error) {
+				if (error instanceof ChatLockContentionError) throw cliError$6(error.message);
+				throw error;
+			} finally {
+				releaseState();
+			}
 			if (!state) throw cliError$6(localId === void 0 ? "No open chat. Start one with `primitive chat <email> '<message>'`." : `No local chat ${localId}. Start one with \`primitive chat <email> '<message>'\` or omit --id to use the active chat.`);
 			const message = args.message !== void 0 ? args.message : args.idOrMessage !== void 0 && args.idOrMessage !== "" ? args.idOrMessage : await readStdinToString("No reply body provided. Pass the reply body as a positional argument or pipe it via stdin.");
 			if (!message.trim()) throw cliError$6("Reply body is empty.");
@@ -29075,7 +29686,7 @@ var ChatReplyCommand = class ChatReplyCommand extends Command {
 			if (flags.time) argv.push("--time");
 			await ChatCommand.run(argv, { root: this.config.root });
 		} finally {
-			release();
+			release?.();
 		}
 	}
 };
@@ -31226,8 +31837,8 @@ const PRIMITIVE_TEAM_AUTHOR = {
 	name: "Primitive Team",
 	url: "https://primitive.dev"
 };
-const SDK_VERSION_RANGE = "^1.23.0";
-const CLI_VERSION_RANGE = "^1.23.0";
+const SDK_VERSION_RANGE = "^1.24.0";
+const CLI_VERSION_RANGE = "^1.24.0";
 const ESBUILD_VERSION_RANGE = "^0.27.0";
 function renderHandler() {
 	return `// env.PRIMITIVE_API_KEY, env.PRIMITIVE_WEBHOOK_SECRET, and
@@ -33475,7 +34086,7 @@ function createListenHandler(options = {}) {
 	validateListenHandlerOptions(options);
 	return async (delivery, signal) => {
 		signal.throwIfAborted();
-		const start = performance.now();
+		const start = performance$1.now();
 		const work = new AbortController();
 		let timedOut = false;
 		const cancel = () => work.abort(signal.reason);
@@ -33484,7 +34095,7 @@ function createListenHandler(options = {}) {
 			timedOut = true;
 			work.abort(/* @__PURE__ */ new Error("Event handler timed out."));
 		}, HANDLER_TIMEOUT_MS);
-		const duration = () => Math.min(HANDLER_TIMEOUT_MS, Math.max(0, Math.round(performance.now() - start)));
+		const duration = () => Math.min(HANDLER_TIMEOUT_MS, Math.max(0, Math.round(performance$1.now() - start)));
 		try {
 			if (options.exec !== void 0) {
 				const code = await execute(options.exec, delivery, options.stderr ?? process.stderr, work.signal);
@@ -36122,7 +36733,7 @@ var OrgSecretsSetCommand = class OrgSecretsSetCommand extends Command {
 	}
 };
 //#endregion
-//#region ../sdk-node/dist/payloads-CQtSsUT6.js
+//#region ../sdk-node/dist/payloads-BfJAtqW9.js
 /**
 * Load a Node builtin at call time. Exported for direct testing of the
 * unavailable-module error path; production code goes through the typed
@@ -36155,7 +36766,9 @@ const MANIFEST_VERSION = 1;
 const CHUNK_KDF_INFO = "payloads-chunk";
 const OBJECT_ID_BYTES = 16;
 const CEK_BYTES = 32;
-const subtle = globalThis.crypto.subtle;
+function subtle() {
+	return globalThis.crypto.subtle;
+}
 const textEncoder = new TextEncoder();
 function randomBytes(length) {
 	const out = new Uint8Array(length);
@@ -36175,7 +36788,7 @@ function fromHex(hex) {
 	return out;
 }
 async function contentHash(bytes) {
-	return new Uint8Array(await subtle.digest("SHA-256", bytes));
+	return new Uint8Array(await subtle().digest("SHA-256", bytes));
 }
 async function contentHashHex(bytes) {
 	return toHex(await contentHash(bytes));
@@ -36199,9 +36812,9 @@ async function merkleRoot(leafHashesHex) {
 	return toHex(level[0]);
 }
 async function deriveChunkKey(cek, index) {
-	const baseKey = await subtle.importKey("raw", cek, "HKDF", false, ["deriveKey"]);
+	const baseKey = await subtle().importKey("raw", cek, "HKDF", false, ["deriveKey"]);
 	const info = textEncoder.encode(`${CHUNK_KDF_INFO}:${index}`);
-	return subtle.deriveKey({
+	return subtle().deriveKey({
 		name: "HKDF",
 		hash: "SHA-256",
 		salt: new Uint8Array(32),
@@ -36224,7 +36837,7 @@ function chunkAad(objectId, index) {
 }
 async function encryptChunk(cek, objectId, index, plaintext) {
 	const key = await deriveChunkKey(cek, index);
-	const ct = await subtle.encrypt({
+	const ct = await subtle().encrypt({
 		name: "AES-GCM",
 		iv: chunkNonce(index),
 		additionalData: chunkAad(objectId, index)
@@ -36233,7 +36846,7 @@ async function encryptChunk(cek, objectId, index, plaintext) {
 }
 async function decryptChunk(cek, objectId, index, ciphertext) {
 	const key = await deriveChunkKey(cek, index);
-	const pt = await subtle.decrypt({
+	const pt = await subtle().decrypt({
 		name: "AES-GCM",
 		iv: chunkNonce(index),
 		additionalData: chunkAad(objectId, index)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primitive",
-  "version": "1.23.0",
+  "version": "1.24.0",
   "description": "Official Primitive CLI: deploy Primitive Functions, send and inspect mail, manage endpoints, all from the terminal. Wraps the @primitivedotdev/sdk runtime client with one-shot commands.",
   "type": "module",
   "sideEffects": false,
@@ -172,12 +172,12 @@
     "@primitivedotdev/api-core": "workspace:*",
     "@primitivedotdev/sdk": "workspace:*",
     "@types/node": "^22.10.2",
-    "@vitest/coverage-v8": "^4.1.4",
+    "@vitest/coverage-v8": "^4.1.11",
     "oclif": "^4.23.0",
     "tsdown": "^0.21.10",
     "tsx": "^4.21.0",
     "typescript": "^5.7.2",
     "vite": "^8.0.8",
-    "vitest": "^4.1.4"
+    "vitest": "^4.1.11"
   }
 }