@moxt-ai/mobius 0.0.323 → 0.0.324

package/dist/cli.js

@@ -2086,7 +2086,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@moxt-ai/mobius",
-      version: "0.0.323",
+      version: "0.0.324",
       description: "Mobius CLI for pairing and running local AI agent services.",
       type: "module",
       bin: {
@@ -70855,11 +70855,10 @@ var init_windows = __esm({
     windowsPermissions = `
 $ErrorActionPreference = 'Stop'
 $ProgressPreference = 'SilentlyContinue'
-Import-Module (Join-Path $PSHOME 'Modules/Microsoft.PowerShell.Security/Microsoft.PowerShell.Security.psd1')
 $item = Get-Item -LiteralPath $env:MOBIUS_PERMISSION_PATH -Force
 if (($item.Attributes -band [IO.FileAttributes]::ReparsePoint) -ne 0) { throw 'Unsafe path' }
 $sid = [Security.Principal.WindowsIdentity]::GetCurrent().User
-$acl = Get-Acl -LiteralPath $item.FullName
+$acl = $item.GetAccessControl()
 $owner = $acl.GetOwner([Security.Principal.SecurityIdentifier])
 if ($owner -ne $sid -and -not ($owner.Value -eq 'S-1-5-32-544' -and ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator))) { throw 'Path is not user-owned' }
 if ($env:MOBIUS_PERMISSION_PRIVATE -eq '1') {
@@ -70873,7 +70872,7 @@ if ($env:MOBIUS_PERMISSION_PRIVATE -eq '1') {
     $private.SetOwner($sid)
     $private.SetAccessRuleProtection($true, $false)
     $private.AddAccessRule($rule)
-    Set-Acl -LiteralPath $item.FullName -AclObject $private
+    $item.SetAccessControl($private)
 }
 `;
     windowsPermissionsTimeoutMs = 3e4;
@@ -74107,6 +74106,8 @@ var init_configuration = __esm({
       ...sessionIdentityFields,
       booleanValue: external_exports.boolean(),
       configId: external_exports.string().min(1).max(128),
+      // Omitted by legacy clients: explicit edits retain last-write-wins behavior.
+      expectedConfigurationRevision: identifierStringSchema.optional(),
       kind: external_exports.literal(SESSION_CONFIGURE_KIND),
       requestId: identifierStringSchema,
       value: external_exports.string().max(500),
@@ -74114,6 +74115,8 @@ var init_configuration = __esm({
     }).readonly();
     sessionConfigUpdatedEventSchema = external_exports.object({
       configOptions: sessionConfigOptionsSchema,
+      // An opaque Runtime generation token; absent on older Runtimes.
+      configurationRevision: identifierStringSchema.optional(),
       kind: external_exports.literal(SESSION_CONFIG_UPDATED_KIND),
       requestId: identifierStringSchema,
       sessionId: identifierStringSchema
@@ -74132,6 +74135,8 @@ var init_configuration = __esm({
     }).readonly();
     sessionConfigReadResultSchema = external_exports.object({
       configOptions: sessionConfigOptionsSchema,
+      // An opaque Runtime generation token; absent on older Runtimes.
+      configurationRevision: identifierStringSchema.optional(),
       kind: external_exports.literal(SESSION_CONFIG_READ_RESULT_KIND),
       requestId: identifierStringSchema,
       sessionId: identifierStringSchema
@@ -74174,7 +74179,60 @@ var init_title = __esm({
 });
 
 // ../mobius-sdk/src/protocol/session/files/index.ts
-var FILE_READ_KIND, FILE_BEGIN_KIND, FILE_CHUNK_KIND, FILE_END_KIND, FILE_FAILED_KIND, fileReadCommandSchema, fileBeginEventSchema, fileChunkEventSchema, fileEndEventSchema, fileFailedEventSchema, decodeFileReadCommand, encodeFileReadCommand, decodeFileBeginEvent, encodeFileBeginEvent, decodeFileChunkEvent, encodeFileChunkEvent, decodeFileEndEvent, encodeFileEndEvent, decodeFileFailedEvent, encodeFileFailedEvent;
+function binaryBytes(value) {
+  if (value instanceof ArrayBuffer) {
+    return new Uint8Array(value);
+  }
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  throw new Error("Content chunk must be a binary WebSocket frame");
+}
+function encodeContentChunkFrame(frame) {
+  if (!isIdentifier(frame.requestId)) {
+    throw new Error("Content chunk request identifier is invalid");
+  }
+  if (!Number.isSafeInteger(frame.sequence) || frame.sequence < 0 || frame.sequence > 4294967295) {
+    throw new Error("Content chunk sequence is invalid");
+  }
+  if (frame.bytes.byteLength < 1 || frame.bytes.byteLength > CONTENT_CHUNK_MAX_BYTES) {
+    throw new Error("Content chunk size is invalid");
+  }
+  const requestId = new TextEncoder().encode(frame.requestId);
+  if (requestId.byteLength > 255) {
+    throw new Error("Content chunk request identifier is too long");
+  }
+  const encoded = new Uint8Array(CONTENT_CHUNK_HEADER_BYTES + requestId.byteLength + frame.bytes.byteLength);
+  encoded.set(CONTENT_CHUNK_MAGIC, 0);
+  encoded[CONTENT_CHUNK_MAGIC.byteLength] = requestId.byteLength;
+  new DataView(encoded.buffer).setUint32(CONTENT_CHUNK_MAGIC.byteLength + 1, frame.sequence);
+  encoded.set(requestId, CONTENT_CHUNK_HEADER_BYTES);
+  encoded.set(frame.bytes, CONTENT_CHUNK_HEADER_BYTES + requestId.byteLength);
+  return encoded;
+}
+function decodeContentChunkFrame(value) {
+  const encoded = binaryBytes(value);
+  if (encoded.byteLength <= CONTENT_CHUNK_HEADER_BYTES || !CONTENT_CHUNK_MAGIC.every((byte, index2) => encoded[index2] === byte)) {
+    throw new Error("Content chunk frame header is invalid");
+  }
+  const requestIdLength = encoded[CONTENT_CHUNK_MAGIC.byteLength] ?? 0;
+  const payloadOffset = CONTENT_CHUNK_HEADER_BYTES + requestIdLength;
+  if (requestIdLength < 1 || payloadOffset >= encoded.byteLength) {
+    throw new Error("Content chunk frame length is invalid");
+  }
+  const requestId = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(
+    encoded.subarray(CONTENT_CHUNK_HEADER_BYTES, payloadOffset)
+  );
+  const bytes = encoded.slice(payloadOffset);
+  const sequence = new DataView(encoded.buffer, encoded.byteOffset, encoded.byteLength).getUint32(
+    CONTENT_CHUNK_MAGIC.byteLength + 1
+  );
+  if (!isIdentifier(requestId) || bytes.byteLength > CONTENT_CHUNK_MAX_BYTES) {
+    throw new Error("Content chunk frame is invalid");
+  }
+  return { bytes, requestId, sequence };
+}
+var FILE_READ_KIND, FILE_BEGIN_KIND, FILE_END_KIND, FILE_FAILED_KIND, CONTENT_WRITE_KIND, CONTENT_COMMIT_KIND, CONTENT_READY_KIND, CONTENT_AVAILABLE_KIND, CONTENT_CHUNK_MAX_BYTES, CONTENT_WRITE_MAX_BYTES, PROMPT_IMAGE_MAX_BYTES, CONTENT_CHUNK_MAGIC, CONTENT_CHUNK_HEADER_BYTES, fileReadCommandSchema, fileBeginEventSchema, contentWriteCommandSchema, contentCommitCommandSchema, contentReadyEventSchema, contentAvailableEventSchema, fileEndEventSchema, fileFailedEventSchema, decodeFileReadCommand, encodeFileReadCommand, decodeFileBeginEvent, encodeFileBeginEvent, decodeFileEndEvent, encodeFileEndEvent, decodeFileFailedEvent, encodeFileFailedEvent, decodeContentWriteCommand, encodeContentWriteCommand, decodeContentCommitCommand, encodeContentCommitCommand, decodeContentReadyEvent, encodeContentReadyEvent, decodeContentAvailableEvent, encodeContentAvailableEvent;
 var init_files = __esm({
   "../mobius-sdk/src/protocol/session/files/index.ts"() {
     "use strict";
@@ -74183,9 +74241,17 @@ var init_files = __esm({
     init_message_codec();
     FILE_READ_KIND = "file.read";
     FILE_BEGIN_KIND = "file.begin";
-    FILE_CHUNK_KIND = "file.chunk";
     FILE_END_KIND = "file.end";
     FILE_FAILED_KIND = "file.failed";
+    CONTENT_WRITE_KIND = "content.write";
+    CONTENT_COMMIT_KIND = "content.commit";
+    CONTENT_READY_KIND = "content.ready";
+    CONTENT_AVAILABLE_KIND = "content.available";
+    CONTENT_CHUNK_MAX_BYTES = 192 * 1024;
+    CONTENT_WRITE_MAX_BYTES = 32 * 1024 * 1024;
+    PROMPT_IMAGE_MAX_BYTES = 5e6;
+    CONTENT_CHUNK_MAGIC = new Uint8Array([77, 66, 67, 49]);
+    CONTENT_CHUNK_HEADER_BYTES = CONTENT_CHUNK_MAGIC.byteLength + 1 + 4;
     fileReadCommandSchema = external_exports.object({
       kind: external_exports.literal(FILE_READ_KIND),
       maxBytes: external_exports.number().int().positive().max(128 * 1024 * 1024),
@@ -74202,11 +74268,31 @@ var init_files = __esm({
       requestId: identifierStringSchema,
       sessionId: identifierStringSchema
     }).readonly();
-    fileChunkEventSchema = external_exports.object({
-      data: external_exports.string().min(1).max(4e5),
-      kind: external_exports.literal(FILE_CHUNK_KIND),
+    contentWriteCommandSchema = external_exports.object({
+      byteLength: external_exports.number().int().positive().max(CONTENT_WRITE_MAX_BYTES),
+      contentKey: external_exports.string().regex(/^[a-f0-9]{64}$/u),
+      contentKind: external_exports.enum(["image", "resource"]),
+      kind: external_exports.literal(CONTENT_WRITE_KIND),
+      mediaType: external_exports.string().min(1).max(255),
+      name: external_exports.string().min(1).max(500),
+      requestId: identifierStringSchema,
+      sessionId: identifierStringSchema
+    }).readonly();
+    contentCommitCommandSchema = external_exports.object({
+      kind: external_exports.literal(CONTENT_COMMIT_KIND),
+      requestId: identifierStringSchema,
+      sessionId: identifierStringSchema
+    }).readonly();
+    contentReadyEventSchema = external_exports.object({
+      kind: external_exports.literal(CONTENT_READY_KIND),
+      requestId: identifierStringSchema,
+      sessionId: identifierStringSchema
+    }).readonly();
+    contentAvailableEventSchema = external_exports.object({
+      byteLength: external_exports.number().int().positive().max(CONTENT_WRITE_MAX_BYTES),
+      contentKey: external_exports.string().regex(/^[a-f0-9]{64}$/u),
+      kind: external_exports.literal(CONTENT_AVAILABLE_KIND),
       requestId: identifierStringSchema,
-      sequence: external_exports.number().int().nonnegative().max(1024),
       sessionId: identifierStringSchema
     }).readonly();
     fileEndEventSchema = external_exports.object({
@@ -74225,12 +74311,18 @@ var init_files = __esm({
     encodeFileReadCommand = (message) => encodeZodMessage(message, fileReadCommandSchema);
     decodeFileBeginEvent = (encoded) => decodeZodMessage(encoded, fileBeginEventSchema);
     encodeFileBeginEvent = (message) => encodeZodMessage(message, fileBeginEventSchema);
-    decodeFileChunkEvent = (encoded) => decodeZodMessage(encoded, fileChunkEventSchema);
-    encodeFileChunkEvent = (message) => encodeZodMessage(message, fileChunkEventSchema);
     decodeFileEndEvent = (encoded) => decodeZodMessage(encoded, fileEndEventSchema);
     encodeFileEndEvent = (message) => encodeZodMessage(message, fileEndEventSchema);
     decodeFileFailedEvent = (encoded) => decodeZodMessage(encoded, fileFailedEventSchema);
     encodeFileFailedEvent = (message) => encodeZodMessage(message, fileFailedEventSchema);
+    decodeContentWriteCommand = (encoded) => decodeZodMessage(encoded, contentWriteCommandSchema);
+    encodeContentWriteCommand = (message) => encodeZodMessage(message, contentWriteCommandSchema);
+    decodeContentCommitCommand = (encoded) => decodeZodMessage(encoded, contentCommitCommandSchema);
+    encodeContentCommitCommand = (message) => encodeZodMessage(message, contentCommitCommandSchema);
+    decodeContentReadyEvent = (encoded) => decodeZodMessage(encoded, contentReadyEventSchema);
+    encodeContentReadyEvent = (message) => encodeZodMessage(message, contentReadyEventSchema);
+    decodeContentAvailableEvent = (encoded) => decodeZodMessage(encoded, contentAvailableEventSchema);
+    encodeContentAvailableEvent = (message) => encodeZodMessage(message, contentAvailableEventSchema);
   }
 });
 
@@ -74584,6 +74676,7 @@ var init_lifecycle = __esm({
       capabilities: sessionCapabilitiesSchema,
       commands: external_exports.array(sessionCommandSchema).max(500).readonly(),
       configOptions: sessionConfigOptionsSchema,
+      configurationRevision: identifierStringSchema.optional(),
       directoryId: DIRECTORY_IDENTIFIER,
       directoryLabel: external_exports.string().min(1).max(MAX_WORKSPACE_PATH_LENGTH),
       kind: external_exports.literal(SESSION_READY_KIND),
@@ -74678,13 +74771,12 @@ function decodeSessionPromptCommand(encoded) {
   const hasSessionConfigurations = Object.hasOwn(value, "sessionConfigurations");
   assertKind(value, SESSION_PROMPT_KIND);
   const prompt = readText(value, "prompt", MAX_PROMPT_LENGTH);
-  const images = decodePromptImagesValue(value["images"]);
-  const resources = decodePromptResourcesValue(value["resources"]);
-  const attachmentLength = images.reduce((total, image) => total + image.data.length, 0) + resources.reduce((total, resource) => total + resource.text.length, 0);
-  if (attachmentLength > MAX_PROMPT_ATTACHMENT_LENGTH) {
+  const attachments = !Object.hasOwn(value, "attachments") && Array.isArray(value["images"]) && Array.isArray(value["resources"]) ? [] : decodePromptAttachmentsValue(value["attachments"]);
+  const attachmentBytes = attachments.reduce((total, attachment) => total + attachment.byteLength, 0);
+  if (attachmentBytes > MAX_PROMPT_ATTACHMENT_BYTES) {
     throw new ProtocolMessageError("Prompt attachments are too large");
   }
-  if (prompt.trim().length === 0 && images.length === 0 && resources.length === 0) {
+  if (prompt.trim().length === 0 && attachments.length === 0) {
     throw new ProtocolMessageError("Prompt must contain content");
   }
   const disposition = readPromptDisposition(value);
@@ -74704,13 +74796,12 @@ function decodeSessionPromptCommand(encoded) {
     commandId: readIdentifier(value, "commandId"),
     directoryId: readDirectoryIdentifier(value, "directoryId"),
     disposition,
-    images,
+    attachments,
     ...value["historyPolicy"] === void 0 ? {} : {
       historyPolicy: readHistoryPolicy(value)
     },
     kind: SESSION_PROMPT_KIND,
     prompt,
-    resources,
     ...hasSessionConfigurations ? { sessionConfigurations } : {},
     sessionId: readIdentifier(value, "sessionId"),
     targetCommandId
@@ -74746,7 +74837,15 @@ function decodeSessionPromptDispositionCommand(encoded) {
   };
 }
 function encodeSessionPromptCommand(message) {
-  return JSON.stringify(decodeSessionPromptCommand(JSON.stringify(message)));
+  const command = decodeSessionPromptCommand(JSON.stringify(message));
+  return JSON.stringify({
+    ...command,
+    // Keep text prompts compatible with the previous Runtime release while
+    // attachments move to the content-key protocol. Older Runtimes ignore
+    // `attachments` and require both legacy arrays to be present.
+    images: [],
+    resources: []
+  });
 }
 function encodeSessionCancelCommand(message) {
   return JSON.stringify(decodeSessionCancelCommand(JSON.stringify(message)));
@@ -74754,7 +74853,7 @@ function encodeSessionCancelCommand(message) {
 function encodeSessionPromptDispositionCommand(message) {
   return JSON.stringify(decodeSessionPromptDispositionCommand(JSON.stringify(message)));
 }
-var SESSION_PROMPT_KIND, SESSION_PROMPT_DISPOSITION_KIND, SESSION_CANCEL_KIND, SessionPromptDisposition, SessionHistoryPolicy, MAX_PROMPT_LENGTH, MAX_PROMPT_ATTACHMENT_LENGTH, promptImageSchema, promptResourceSchema, decodePromptImagesValue, decodePromptResourcesValue;
+var SESSION_PROMPT_KIND, SESSION_PROMPT_DISPOSITION_KIND, SESSION_CANCEL_KIND, SessionPromptDisposition, SessionHistoryPolicy, MAX_PROMPT_LENGTH, MAX_PROMPT_ATTACHMENT_BYTES, promptAttachmentSchema, decodePromptAttachmentsValue;
 var init_commands = __esm({
   "../mobius-sdk/src/protocol/session/prompt/commands.ts"() {
     "use strict";
@@ -74775,21 +74874,16 @@ var init_commands = __esm({
       ExecutionOnly: "execution-only"
     });
     MAX_PROMPT_LENGTH = 1e5;
-    MAX_PROMPT_ATTACHMENT_LENGTH = 6e6;
-    promptImageSchema = external_exports.object({
-      data: external_exports.string().min(1).max(4e6),
+    MAX_PROMPT_ATTACHMENT_BYTES = 32 * 1024 * 1024;
+    promptAttachmentSchema = external_exports.object({
+      byteLength: external_exports.number().int().positive().max(MAX_PROMPT_ATTACHMENT_BYTES),
+      contentKey: external_exports.string().regex(/^[a-f0-9]{64}$/u),
+      kind: external_exports.enum(["image", "resource"]),
       mimeType: external_exports.string().min(1).max(255),
-      name: external_exports.string().min(1).max(500)
-    }).readonly();
-    promptResourceSchema = external_exports.object({
-      mimeType: external_exports.string().max(255),
       name: external_exports.string().min(1).max(500),
-      text: external_exports.string().max(1e6),
-      type: external_exports.enum(["embedded", "link"]),
       uri: external_exports.string().min(1).max(4096)
     }).readonly();
-    decodePromptImagesValue = (value) => decodeZodValue(value, external_exports.array(promptImageSchema).max(8).readonly());
-    decodePromptResourcesValue = (value) => decodeZodValue(value, external_exports.array(promptResourceSchema).max(16).readonly());
+    decodePromptAttachmentsValue = (value) => decodeZodValue(value, external_exports.array(promptAttachmentSchema).max(16).readonly());
   }
 });
 
@@ -74889,9 +74983,7 @@ var init_native = __esm({
           external_exports.object({
             commandId: identifierStringSchema,
             prompt: external_exports.string().max(1e5),
-            images: external_exports.array(promptImageSchema).max(8).readonly(),
-            // Absent from daemons that predate it; a client then cannot restore the prompt's files.
-            resources: external_exports.array(promptResourceSchema).max(16).readonly().optional()
+            attachments: external_exports.array(promptAttachmentSchema).max(16).readonly()
           }).readonly()
         ).readonly(),
         turn: activeTurnSnapshotSchema.nullable()
@@ -75896,6 +75988,16 @@ var init_daemon_transport = __esm({
         decodeAgentCatalogDiscoverCommand
       ),
       [FILE_READ_KIND]: defineMessageSignature(FILE_READ_KIND, encodeFileReadCommand, decodeFileReadCommand),
+      [CONTENT_WRITE_KIND]: defineMessageSignature(
+        CONTENT_WRITE_KIND,
+        encodeContentWriteCommand,
+        decodeContentWriteCommand
+      ),
+      [CONTENT_COMMIT_KIND]: defineMessageSignature(
+        CONTENT_COMMIT_KIND,
+        encodeContentCommitCommand,
+        decodeContentCommitCommand
+      ),
       [SESSION_LIST_KIND]: defineMessageSignature(SESSION_LIST_KIND, encodeSessionListCommand, decodeSessionListCommand),
       [SESSION_QUERY_KIND]: defineMessageSignature(
         SESSION_QUERY_KIND,
@@ -76047,9 +76149,14 @@ var init_daemon_transport = __esm({
         decodeAgentCatalogDiscoveryFailedEvent
       ),
       [FILE_BEGIN_KIND]: defineMessageSignature(FILE_BEGIN_KIND, encodeFileBeginEvent, decodeFileBeginEvent),
-      [FILE_CHUNK_KIND]: defineMessageSignature(FILE_CHUNK_KIND, encodeFileChunkEvent, decodeFileChunkEvent),
       [FILE_END_KIND]: defineMessageSignature(FILE_END_KIND, encodeFileEndEvent, decodeFileEndEvent),
       [FILE_FAILED_KIND]: defineMessageSignature(FILE_FAILED_KIND, encodeFileFailedEvent, decodeFileFailedEvent),
+      [CONTENT_READY_KIND]: defineMessageSignature(CONTENT_READY_KIND, encodeContentReadyEvent, decodeContentReadyEvent),
+      [CONTENT_AVAILABLE_KIND]: defineMessageSignature(
+        CONTENT_AVAILABLE_KIND,
+        encodeContentAvailableEvent,
+        decodeContentAvailableEvent
+      ),
       [SESSION_LISTED_KIND]: defineMessageSignature(
         SESSION_LISTED_KIND,
         encodeSessionsListedEvent,
@@ -93501,7 +93608,8 @@ var init_session_api = __esm({
       configOptions;
       prompted;
       restored;
-      constructor(agentName, agentVersion, capabilities, commands, configOptions, prompted, restored) {
+      configurationRevision;
+      constructor(agentName, agentVersion, capabilities, commands, configOptions, prompted, restored, configurationRevision) {
         this.agentName = agentName;
         this.agentVersion = agentVersion;
         this.capabilities = capabilities;
@@ -93509,6 +93617,7 @@ var init_session_api = __esm({
         this.configOptions = configOptions;
         this.prompted = prompted;
         this.restored = restored;
+        this.configurationRevision = configurationRevision;
       }
     };
     AgentSettingsSnapshot = class {
@@ -94573,6 +94682,7 @@ var init_agent_session = __esm({
     init_prompt_content();
     init_session_capabilities();
     init_session_config_protocol();
+    init_serial_task_queue();
     init_value_utils();
     init_session_api();
     init_session_history();
@@ -94632,7 +94742,8 @@ var init_agent_session = __esm({
       #agentVersion = "";
       #capabilities = unsupportedSessionCapabilities();
       #commands = [];
-      #configRevision = 0;
+      #configRevision = crypto.randomUUID();
+      #configurationChanges = new SerialTaskQueue();
       #configOptions = [];
       #sessionConfigurations = new SessionConfigurations();
       #nativeHistoryOwnership = { kind: "unbound" };
@@ -94801,7 +94912,8 @@ var init_agent_session = __esm({
         this.#commands,
         this.#configOptions,
         this.#prompted,
-        this.#restored
+        this.#restored,
+        this.#configRevision
       );
       ensureHistoryLoaded = async (signal) => {
         if (!this.#capabilities.loadSession) {
@@ -94931,12 +95043,23 @@ var init_agent_session = __esm({
         const configured = await this.#adapter.configureSession(this.#target(), selection, signal);
         if (this.#configRevision === configRevision) {
           this.#configOptions = configured;
+          this.#configRevision = crypto.randomUUID();
+          await this.#publishConfiguration();
         }
       };
-      configure = async (options) => {
+      // The revision check and Agent mutation share one queue, including legacy callers.
+      // A lost response may have committed: reread after a conflict, never replay an edit blindly.
+      configure = async (options) => this.#configurationChanges.run(async (signal) => {
+        if (options.expectedConfigurationRevision !== void 0 && options.expectedConfigurationRevision !== this.#configRevision) {
+          throw new AcpExecutionError(
+            "Session settings changed. Review the current settings before applying your selection again.",
+            {},
+            "session_configuration_conflict"
+          );
+        }
         await this.#applyConfiguration(
           options.valueType === "boolean" ? { type: "boolean", configId: options.configId, booleanValue: options.booleanValue } : { type: "select", configId: options.configId, value: options.value },
-          options.signal
+          signal
         );
         const applied = this.#configOptions.find((option) => option.id === options.configId);
         if (applied === void 0) {
@@ -94944,7 +95067,24 @@ var init_agent_session = __esm({
         }
         this.#sessionConfigurations.select(applied);
         this.writeStoredSession((/* @__PURE__ */ new Date()).toISOString());
-        return this.#configOptions;
+        return { configOptions: this.#configOptions, configurationRevision: this.#configRevision };
+      }, options.signal);
+      #publishConfiguration = async () => {
+        const event = this.#store.events.append(this.#mobiusSessionId, {
+          type: "acp",
+          payload: {
+            sessionUpdate: "config_option_update",
+            configOptions: this.#configOptions.map((option) => ({
+              category: option.category,
+              description: option.description,
+              id: option.id,
+              name: option.name,
+              ...option.type === "boolean" ? { type: "boolean", currentValue: option.booleanValue } : { type: "select", currentValue: option.currentValue, options: option.values }
+            }))
+          }
+        });
+        await this.#getObserver().onSessionEvent?.(event);
+        await this.emitConfigUpdate();
       };
       #target = () => ({
         nativeSessionId: this.#updates.sessionId(),
@@ -95122,6 +95262,13 @@ var init_agent_session = __esm({
         this.#nativeHistoryOwnership = { kind: "agent-owned" };
       };
       #processEvent = async (event) => {
+        if (event.kind === "configuration" || event.kind === "mode") {
+          this.#configOptions = event.kind === "configuration" ? event.configOptions : this.#configOptions.map(
+            (option) => option.category === "mode" ? { ...option, currentValue: event.modeId } : option
+          );
+          this.#configRevision = crypto.randomUUID();
+          this.#captureSelectedConfigurationValues();
+        }
         if (this.#sessionLoad.kind === "capturing") {
           await this.#sessionLoad.history.record(event.payload);
         } else if (this.#sessionLoad.kind === "loaded" || this.#sessionLoad.kind === "execution-only") {
@@ -95142,17 +95289,7 @@ var init_agent_session = __esm({
             });
             return;
           case "configuration":
-            this.#configOptions = event.configOptions;
-            this.#configRevision += 1;
-            this.#captureSelectedConfigurationValues();
-            await this.emitConfigUpdate();
-            return;
           case "mode":
-            this.#configOptions = this.#configOptions.map(
-              (option) => option.category === "mode" ? { ...option, currentValue: event.modeId } : option
-            );
-            this.#configRevision += 1;
-            this.#captureSelectedConfigurationValues();
             await this.emitConfigUpdate();
             return;
           case "info":
@@ -95215,6 +95352,7 @@ var init_agent_session = __esm({
       }
       setConfigOptions(options) {
         this.#configOptions = options;
+        this.#configRevision = crypto.randomUUID();
       }
       setNativeHistoryOwnership(ownership) {
         this.#nativeHistoryOwnership = ownership;
@@ -95236,6 +95374,7 @@ var init_agent_session = __esm({
       emitConfigUpdate = async () => {
         await this.#getObserver().onConfig({
           configOptions: this.#configOptions,
+          configurationRevision: this.#configRevision,
           kind: SESSION_CONFIG_UPDATED_KIND,
           requestId: `agent-update-${crypto.randomUUID()}`,
           sessionId: this.#mobiusSessionId
@@ -95663,7 +95802,7 @@ var init_session_manager = __esm({
               (option) => option.id === "model" || option.category === "model"
             );
             const modelIsFixed = modelOption2?.type === "select" && modelOption2.values.length < 2 && modelOption2.currentValue === model;
-            const configOptions = model === void 0 || modelIsFixed ? prepared.configOptions : await runtime.configure({
+            const configOptions = model === void 0 || modelIsFixed ? prepared.configOptions : (await runtime.configure({
               ...options2,
               booleanValue: false,
               configId: modelOption2?.id ?? "model",
@@ -95671,7 +95810,7 @@ var init_session_manager = __esm({
               sessionId: `agent-settings-${crypto.randomUUID()}`,
               value: model,
               valueType: "select"
-            });
+            })).configOptions;
             return new AgentSettingsSnapshot(
               prepared.agentName,
               prepared.agentVersion,
@@ -96525,19 +96664,22 @@ function promptContent(command) {
   if (command.prompt.length > 0) {
     content.push({ text: command.prompt, type: "text" });
   }
-  for (const image of command.images) {
-    content.push({
-      data: image.data,
-      mimeType: image.mimeType,
-      type: "image"
-    });
-  }
-  for (const resource of command.resources) {
+  for (const attachment of command.attachments) {
     content.push(
-      resource.type === "embedded" ? {
-        resource: { mimeType: resource.mimeType, text: resource.text, uri: resource.uri },
-        type: "resource"
-      } : { mimeType: resource.mimeType, name: resource.name, type: "resource_link", uri: resource.uri }
+      attachment.kind === "image" ? {
+        byteLength: attachment.byteLength,
+        imageKey: attachment.contentKey,
+        mimeType: attachment.mimeType,
+        type: "external_image",
+        uri: attachment.uri
+      } : {
+        byteLength: attachment.byteLength,
+        encoding: "text",
+        mimeType: attachment.mimeType,
+        resourceKey: attachment.contentKey,
+        type: "external_resource",
+        uri: attachment.uri
+      }
     );
   }
   return content;
@@ -97258,8 +97400,7 @@ var init_session_turns = __esm({
             queued.push({
               commandId: candidate.command.commandId,
               prompt: candidate.command.prompt,
-              images: candidate.command.images,
-              resources: candidate.command.resources
+              attachments: candidate.command.attachments
             });
           }
           return { turn: turnSnapshot ?? null, queued };
@@ -97584,7 +97725,7 @@ var init_session_layer = __esm({
 
 // src/storage/files/scratch-directory.ts
 import { randomUUID as randomUUID16 } from "node:crypto";
-import { lstat as lstat6, mkdir as mkdir5, readdir as readdir7, realpath as realpath9, rename as rename5, rm as rm4, stat as stat8, utimes, writeFile as writeFile5 } from "node:fs/promises";
+import { lstat as lstat6, mkdir as mkdir5, readdir as readdir7, readFile as readFile12, realpath as realpath9, rename as rename5, rm as rm4, stat as stat8, utimes, writeFile as writeFile5 } from "node:fs/promises";
 import { dirname as dirname12, join as join34 } from "node:path";
 async function atomicWrite(path8, bytes, signal) {
   const temporary = `${path8}.${randomUUID16()}.tmp`;
@@ -97652,6 +97793,12 @@ var init_scratch_directory = __esm({
           return null;
         }
       };
+      /** Reads a regular file owned by this scratch directory after validating its canonical path. */
+      read = async (path8, signal) => {
+        const resolved = await this.resolveFile(path8);
+        signal.throwIfAborted();
+        return resolved === null ? null : new Uint8Array(await readFile12(resolved, { signal }));
+      };
       removeAll = async () => {
         await rm4(this.#root, { force: true, recursive: true });
       };
@@ -97763,6 +97910,11 @@ var init_external_content_store = __esm({
         signal.throwIfAborted();
         return resolvedPath === null ? null : { mediaType: entry.mediaType, name: entry.name, path: resolvedPath };
       };
+      read = (sessionId, request, signal) => this.#track(async () => {
+        const active = AbortSignal.any([signal, this.#lifetime.signal]);
+        const resolved = await this.#resolve(sessionId, request, active);
+        return resolved === null ? null : this.#scratch.read(resolved.path, active);
+      });
       [Symbol.asyncDispose] = async () => {
         clearInterval(this.#expirationTimer);
         this.#lifetime.abort();
@@ -98371,6 +98523,12 @@ function send(socket, message) {
   }
   socket.send(encodeDaemonToServiceMessage(message));
 }
+function sendContentChunk(socket, requestId, sequence, bytes) {
+  if (socket.readyState !== WebSocket2.OPEN) {
+    throw new Error("Relay connection is not open");
+  }
+  socket.send(encodeContentChunkFrame({ bytes, requestId, sequence }));
+}
 function reportOperationFailure(socket, requestId, sessionId, error62, runtimeTimings = []) {
   if (socket.readyState !== WebSocket2.OPEN) {
     return;
@@ -99057,6 +99215,134 @@ var init_agent_settings = __esm({
   }
 });
 
+// src/runtime/command/registry/content-write/index.ts
+import { createHash as createHash10 } from "node:crypto";
+function createContentWriteCommands(context) {
+  const pending = /* @__PURE__ */ new Map();
+  const operations = /* @__PURE__ */ new Set();
+  const fail = (command, error62) => {
+    pending.delete(command.requestId);
+    send(context.socket, {
+      code: "content_write_failed",
+      kind: FILE_FAILED_KIND,
+      message: error62 instanceof Error ? error62.message : "The content could not be stored",
+      requestId: command.requestId,
+      sessionId: command.sessionId
+    });
+  };
+  const write = {
+    kind: CONTENT_WRITE_KIND,
+    handle: (_commandContext, message) => {
+      if (message.kind !== CONTENT_WRITE_KIND) {
+        throw new Error("Command kind mismatch");
+      }
+      const existing = pending.get(message.requestId);
+      if (existing !== void 0) {
+        if (JSON.stringify(existing.command) !== JSON.stringify(message)) {
+          fail(message, new Error("The content request identifier is already in use"));
+          return;
+        }
+      } else {
+        pending.set(message.requestId, {
+          bytes: new Uint8Array(message.byteLength),
+          command: message,
+          hash: createHash10("sha256"),
+          receivedBytes: 0,
+          sequence: 0
+        });
+      }
+      send(context.socket, {
+        kind: CONTENT_READY_KIND,
+        requestId: message.requestId,
+        sessionId: message.sessionId
+      });
+    }
+  };
+  const commit = {
+    kind: CONTENT_COMMIT_KIND,
+    handle: (_commandContext, message) => {
+      if (message.kind !== CONTENT_COMMIT_KIND) {
+        throw new Error("Command kind mismatch");
+      }
+      const state = pending.get(message.requestId);
+      if (state === void 0 || state.command.sessionId !== message.sessionId) {
+        fail(message, new Error("The content upload is unavailable"));
+        return;
+      }
+      pending.delete(message.requestId);
+      const operation = (async () => {
+        try {
+          if (state.receivedBytes !== state.command.byteLength) {
+            throw new Error("The content upload ended at an unexpected length");
+          }
+          if (state.hash.digest("hex") !== state.command.contentKey) {
+            throw new Error("The content upload failed integrity validation");
+          }
+          const stored = await context.externalContent.put({
+            bytes: state.bytes,
+            kind: state.command.contentKind,
+            mediaType: state.command.mediaType,
+            name: state.command.name,
+            sessionId: state.command.sessionId,
+            signal: context.signal
+          });
+          if (stored.key !== state.command.contentKey || stored.byteLength !== state.command.byteLength) {
+            throw new Error("Stored content did not match the upload");
+          }
+          send(context.socket, {
+            byteLength: stored.byteLength,
+            contentKey: stored.key,
+            kind: CONTENT_AVAILABLE_KIND,
+            requestId: message.requestId,
+            sessionId: message.sessionId
+          });
+        } catch (error62) {
+          if (!context.signal.aborted) {
+            fail(message, error62);
+          }
+        }
+      })();
+      operations.add(operation);
+      void operation.finally(() => operations.delete(operation));
+    }
+  };
+  return {
+    commands: [write, commit],
+    receiveChunk: (frame) => {
+      const state = pending.get(frame.requestId);
+      if (state === void 0) {
+        context.diagnostics.daemonDiagnostic("content_chunk_discarded", frame.requestId, {
+          reason: "upload_unavailable",
+          sequence: frame.sequence.toString()
+        });
+        return;
+      }
+      if (frame.sequence !== state.sequence || state.receivedBytes + frame.bytes.byteLength > state.command.byteLength) {
+        fail(state.command, new Error("The content upload contains invalid chunks"));
+        return;
+      }
+      state.bytes.set(frame.bytes, state.receivedBytes);
+      state.hash.update(frame.bytes);
+      pending.set(frame.requestId, {
+        ...state,
+        receivedBytes: state.receivedBytes + frame.bytes.byteLength,
+        sequence: state.sequence + 1
+      });
+    },
+    settle: async () => {
+      pending.clear();
+      await Promise.allSettled([...operations]);
+    }
+  };
+}
+var init_content_write = __esm({
+  "src/runtime/command/registry/content-write/index.ts"() {
+    "use strict";
+    init_protocol();
+    init_transport();
+  }
+});
+
 // src/session/content/session-files.ts
 import { basename as basename9, extname as extname2, isAbsolute as isAbsolute18, join as join37, normalize as normalize3, resolve as resolve18 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
@@ -99099,7 +99385,7 @@ async function resolveFile(value, workingDirectory, signal) {
   }
   return null;
 }
-async function streamLocalFile(command, send2, signal, workingDirectory, externalContent) {
+async function streamLocalFile(command, send2, sendChunk, signal, workingDirectory, externalContent) {
   const external = await externalContent.resolve(command.sessionId, command.path, signal);
   const target = external?.path ?? await resolveFile(command.path, workingDirectory, signal);
   if (target === null) {
@@ -99121,14 +99407,8 @@ async function streamLocalFile(command, send2, signal, workingDirectory, externa
     sessionId: command.sessionId
   });
   let sequence = 0;
-  for await (const bytes of readFileChunks(target, CHUNK_BYTES, signal)) {
-    send2({
-      data: Buffer.from(bytes).toString("base64"),
-      kind: FILE_CHUNK_KIND,
-      requestId: command.requestId,
-      sequence,
-      sessionId: command.sessionId
-    });
+  for await (const bytes of readFileChunks(target, CONTENT_CHUNK_MAX_BYTES, signal)) {
+    sendChunk(command.requestId, sequence, bytes);
     sequence += 1;
   }
   const after = await readPathMetadata(target);
@@ -99142,14 +99422,12 @@ async function streamLocalFile(command, send2, signal, workingDirectory, externa
     sessionId: command.sessionId
   });
 }
-var CHUNK_BYTES;
 var init_session_files = __esm({
   "src/session/content/session-files.ts"() {
     "use strict";
     init_protocol();
     init_raster();
     init_local_files();
-    CHUNK_BYTES = 192 * 1024;
   }
 });
 
@@ -99171,6 +99449,7 @@ var init_file_read = __esm({
         void streamLocalFile(
           message,
           (response) => send(socket, response),
+          (requestId, sequence, bytes) => sendContentChunk(socket, requestId, sequence, bytes),
           signal,
           sessions.findSessions([message.sessionId])[0]?.cwd ?? null,
           externalContent
@@ -99813,7 +100092,7 @@ async function applySessionConfigurationSelection(sessions, options, selection,
   if (sessionConfigurationMatches(option, selection)) {
     return options;
   }
-  return await sessions.configureSession({
+  return (await sessions.configureSession({
     adapter,
     additionalDirectories,
     agent,
@@ -99825,7 +100104,7 @@ async function applySessionConfigurationSelection(sessions, options, selection,
     signal,
     value: selection.value,
     valueType: selection.valueType
-  });
+  })).configOptions;
 }
 async function applyCompleteSessionConfiguration(sessions, initialOptions, selections, agent, adapter, cwd, additionalDirectories, commandId, sessionId, signal) {
   let options = initialOptions;
@@ -99869,98 +100148,70 @@ var init_apply_session_configuration = __esm({
 });
 
 // src/session/prompt/prompt-artifacts.ts
-function parseReference(resource) {
-  let url2;
-  try {
-    url2 = new URL(resource.uri);
-  } catch (cause) {
-    throw new PromptArtifactError("artifact_reference_invalid", "The prompt artifact reference is invalid", {
-      cause
-    });
-  }
-  const keys = [...url2.searchParams.keys()].sort();
-  const artifactId = url2.pathname;
-  const encodedByteLength = url2.searchParams.get("byteLength") ?? "";
-  const sha256 = url2.searchParams.get("sha256") ?? "";
-  const byteLength = Number(encodedByteLength);
-  if (url2.protocol !== ARTIFACT_SCHEME || url2.hash.length > 0 || resource.type !== "link" || resource.text.length > 0 || !isIdentifier(artifactId) || keys.length !== 2 || keys[0] !== "byteLength" || keys[1] !== "sha256" || !/^[1-9][0-9]*$/.test(encodedByteLength) || !Number.isSafeInteger(byteLength) || !/^[a-f0-9]{64}$/.test(sha256)) {
-    throw new PromptArtifactError("artifact_reference_invalid", "The prompt artifact reference is invalid");
-  }
-  return new PromptArtifactReference(artifactId, byteLength, sha256, resource);
-}
+import { createHash as createHash11 } from "node:crypto";
 function isTextMediaType(mediaType) {
   return mediaType.startsWith("text/") || mediaType === "application/json" || mediaType.endsWith("+json") || mediaType === "application/xml" || mediaType.endsWith("+xml");
 }
-async function resolvePromptArtifacts(download, command, signal) {
-  const images = [...command.images];
+async function resolvePromptArtifacts(read, attachments, signal) {
+  const images = [];
   const resources = [];
-  for (const resource of command.resources) {
+  for (const attachment of attachments) {
     signal.throwIfAborted();
-    if (!resource.uri.startsWith(ARTIFACT_SCHEME)) {
-      resources.push(resource);
-      continue;
+    const bytes = await read(attachment, signal);
+    if (bytes.byteLength !== attachment.byteLength || createHash11("sha256").update(bytes).digest("hex") !== attachment.contentKey) {
+      throw new PromptArtifactError(
+        "artifact_integrity_failed",
+        "The prompt attachment failed integrity validation"
+      );
     }
-    const reference = parseReference(resource);
-    const bytes = await download(
-      {
-        artifactId: reference.artifactId,
-        byteLength: reference.byteLength,
-        commandId: command.commandId,
-        mimeType: reference.resource.mimeType,
-        sessionId: command.sessionId,
-        sha256: reference.sha256
-      },
-      signal
-    );
-    if (resource.mimeType.startsWith("image/")) {
-      const data = Buffer.from(bytes).toString("base64");
-      if (data.length > MAX_AGENT_IMAGE_BASE64_LENGTH || images.length >= 8) {
+    if (attachment.kind === "image") {
+      if (bytes.byteLength > PROMPT_IMAGE_MAX_BYTES || images.length >= 8) {
         throw new PromptArtifactError(
           "artifact_too_large_for_agent",
-          "The prompt artifact exceeds the Agent image limit"
+          "The prompt attachment exceeds the Agent image limit"
         );
       }
-      images.push({ data, mimeType: resource.mimeType, name: resource.name });
+      images.push({
+        data: Buffer.from(bytes).toString("base64"),
+        mimeType: attachment.mimeType,
+        name: attachment.name
+      });
       continue;
     }
-    if (!isTextMediaType(resource.mimeType)) {
+    if (!isTextMediaType(attachment.mimeType)) {
       throw new PromptArtifactError(
         "artifact_media_type_unsupported",
-        "The Agent cannot consume this prompt artifact media type"
+        "The Agent cannot consume this prompt attachment media type"
       );
     }
     if (bytes.byteLength > MAX_AGENT_RESOURCE_BYTE_LENGTH || resources.length >= 16) {
       throw new PromptArtifactError(
         "artifact_too_large_for_agent",
-        "The prompt artifact exceeds the Agent resource limit"
+        "The prompt attachment exceeds the Agent resource limit"
       );
     }
     let text2;
     try {
       text2 = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
     } catch (cause) {
-      throw new PromptArtifactError("artifact_encoding_invalid", "The prompt artifact is not valid UTF-8 text", {
-        cause
-      });
+      throw new PromptArtifactError(
+        "artifact_encoding_invalid",
+        "The prompt attachment is not valid UTF-8 text",
+        {
+          cause
+        }
+      );
     }
-    resources.push({
-      mimeType: resource.mimeType,
-      name: resource.name,
-      text: text2,
-      type: "embedded",
-      uri: resource.uri
-    });
+    resources.push({ mimeType: attachment.mimeType, text: text2, type: "embedded", uri: attachment.uri });
   }
   return new ResolvedPromptArtifacts(images, resources);
 }
-var ARTIFACT_SCHEME, MAX_AGENT_IMAGE_BASE64_LENGTH, MAX_AGENT_RESOURCE_BYTE_LENGTH, PromptArtifactError, ResolvedPromptArtifacts, PromptArtifactReference;
+var MAX_AGENT_RESOURCE_BYTE_LENGTH, PromptArtifactError, ResolvedPromptArtifacts;
 var init_prompt_artifacts = __esm({
   "src/session/prompt/prompt-artifacts.ts"() {
     "use strict";
     init_protocol();
     init_operation_error();
-    ARTIFACT_SCHEME = "mobius-artifact:";
-    MAX_AGENT_IMAGE_BASE64_LENGTH = 4e6;
     MAX_AGENT_RESOURCE_BYTE_LENGTH = 1e6;
     PromptArtifactError = class extends OperationError {
       constructor(code, message, options = {}) {
@@ -99976,18 +100227,6 @@ var init_prompt_artifacts = __esm({
         this.resources = resources;
       }
     };
-    PromptArtifactReference = class {
-      artifactId;
-      byteLength;
-      resource;
-      sha256;
-      constructor(artifactId, byteLength, sha256, resource) {
-        this.artifactId = artifactId;
-        this.byteLength = byteLength;
-        this.resource = resource;
-        this.sha256 = sha256;
-      }
-    };
   }
 });
 
@@ -99997,7 +100236,7 @@ async function executePrompt({
   eventProjection,
   command,
   resolveAgent,
-  downloadArtifact,
+  readArtifact,
   reportFailure,
   directories,
   sessions,
@@ -100079,7 +100318,7 @@ async function executePrompt({
       stream.epoch,
       availability.disposition
     );
-    const attachments = await resolvePromptArtifacts(downloadArtifact, command, signal);
+    const attachments = await resolvePromptArtifacts(readArtifact, command.attachments, signal);
     let stopReason;
     if (availability.disposition === SessionPromptDisposition.Steer) {
       await sessions.steerPrompt({
@@ -100150,124 +100389,6 @@ var init_execute_prompt = __esm({
   }
 });
 
-// src/runtime/relay/artifact-download.ts
-import { createHash as createHash10 } from "node:crypto";
-import { fetch as fetch4 } from "undici";
-function downloadUrl(config2, artifact) {
-  const url2 = relayHttpEndpoint(config2.relayUrl);
-  let channelPath = "";
-  if (url2.pathname.endsWith("/daemon")) {
-    channelPath = url2.pathname.slice(0, -"/daemon".length);
-  } else {
-    const runtimePath = "/v1/runtimes/connect";
-    if (!url2.pathname.endsWith(runtimePath)) {
-      throw new PromptArtifactError("artifact_endpoint_invalid", "The Relay artifact endpoint is invalid");
-    }
-    channelPath = `${url2.pathname.slice(0, -runtimePath.length)}/channels/${encodeURIComponent(config2.channelId)}`;
-  }
-  url2.pathname = `${channelPath}/sessions/${encodeURIComponent(artifact.sessionId)}/commands/${encodeURIComponent(artifact.commandId)}/artifacts/${encodeURIComponent(artifact.artifactId)}/content`;
-  return url2;
-}
-async function responseBytes(response, expectedByteLength, signal) {
-  const declaredLength = response.headers.get("content-length") ?? "";
-  if (!/^(0|[1-9][0-9]*)$/.test(declaredLength) || Number(declaredLength) !== expectedByteLength || response.body === null) {
-    throw new PromptArtifactError("artifact_integrity_failed", "The prompt artifact failed integrity validation");
-  }
-  const reader = response.body.getReader();
-  const chunks = [];
-  let byteLength = 0;
-  try {
-    while (true) {
-      signal.throwIfAborted();
-      const chunk = await reader.read();
-      signal.throwIfAborted();
-      if (chunk.done) {
-        break;
-      }
-      byteLength += chunk.value.byteLength;
-      if (byteLength > expectedByteLength) {
-        await reader.cancel("Artifact response exceeded its authorization");
-        throw new PromptArtifactError(
-          "artifact_integrity_failed",
-          "The prompt artifact failed integrity validation"
-        );
-      }
-      chunks.push(chunk.value);
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  if (byteLength !== expectedByteLength) {
-    throw new PromptArtifactError("artifact_integrity_failed", "The prompt artifact failed integrity validation");
-  }
-  const bytes = new Uint8Array(byteLength);
-  let offset = 0;
-  for (const chunk of chunks) {
-    bytes.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return bytes;
-}
-async function downloadPromptArtifact(config2, artifact, signal) {
-  signal.throwIfAborted();
-  const timeoutSignal = AbortSignal.timeout(ARTIFACT_DOWNLOAD_TIMEOUT_MILLISECONDS);
-  const requestSignal = AbortSignal.any([signal, timeoutSignal]);
-  let response;
-  try {
-    response = await fetch4(downloadUrl(config2, artifact), {
-      dispatcher: environmentProxyDispatcher,
-      headers: {
-        accept: artifact.mimeType,
-        "accept-encoding": "identity",
-        ...relayAuthorization(config2.relayUrl)
-      },
-      signal: requestSignal
-    });
-    if (!response.ok) {
-      await response.body?.cancel();
-      throw new PromptArtifactError(
-        "artifact_download_rejected",
-        "The Relay rejected the prompt artifact download"
-      );
-    }
-    if (response.headers.get("content-type") !== artifact.mimeType || response.headers.get("x-mobius-artifact-id") !== artifact.artifactId || response.headers.get("x-mobius-sha256") !== artifact.sha256) {
-      await response.body?.cancel();
-      throw new PromptArtifactError(
-        "artifact_integrity_failed",
-        "The prompt artifact failed integrity validation"
-      );
-    }
-    const bytes = await responseBytes(response, artifact.byteLength, requestSignal);
-    if (createHash10("sha256").update(bytes).digest("hex") !== artifact.sha256) {
-      throw new PromptArtifactError(
-        "artifact_integrity_failed",
-        "The prompt artifact failed integrity validation"
-      );
-    }
-    return bytes;
-  } catch (error62) {
-    signal.throwIfAborted();
-    if (error62 instanceof PromptArtifactError) {
-      throw error62;
-    }
-    throw new PromptArtifactError(
-      timeoutSignal.aborted ? "artifact_download_timeout" : "artifact_download_failed",
-      timeoutSignal.aborted ? "The prompt artifact download timed out" : "The prompt artifact could not be downloaded",
-      { cause: error62 }
-    );
-  }
-}
-var ARTIFACT_DOWNLOAD_TIMEOUT_MILLISECONDS;
-var init_artifact_download = __esm({
-  "src/runtime/relay/artifact-download.ts"() {
-    "use strict";
-    init_prompt_artifacts();
-    init_environment_proxy();
-    init_relay_authentication();
-    ARTIFACT_DOWNLOAD_TIMEOUT_MILLISECONDS = 2e4;
-  }
-});
-
 // src/runtime/command/registry/prompt.ts
 var sessionPromptCommand;
 var init_prompt2 = __esm({
@@ -100275,7 +100396,6 @@ var init_prompt2 = __esm({
     "use strict";
     init_protocol();
     init_execute_prompt();
-    init_artifact_download();
     init_transport();
     sessionPromptCommand = {
       kind: SESSION_PROMPT_KIND,
@@ -100329,7 +100449,17 @@ var init_prompt2 = __esm({
           eventProjection: context.eventProjection,
           command: message,
           resolveAgent: context.resolveAgent,
-          downloadArtifact: (artifact, signal) => downloadPromptArtifact(context.config, artifact, signal),
+          readArtifact: async (artifact, signal) => {
+            const bytes = await context.externalContent.read(
+              message.sessionId,
+              `mobius-content:${artifact.kind}:${artifact.contentKey}`,
+              signal
+            );
+            if (bytes === null) {
+              throw new Error("The prompt attachment is unavailable");
+            }
+            return bytes;
+          },
           reportFailure: context.diagnostics.daemonDiagnostic,
           directories: context.directories,
           sessions: context.sessions,
@@ -100422,7 +100552,7 @@ async function prepareSession(command, recovery, closed, config2, resolveAgent,
     };
     const prepared = command.transient === true ? await sessions.inspectSession(preparation, metrics) : recovery.kind === "history-required" ? await sessions.restoreSession(preparation, metrics, closed) : await sessions.prepareSession(preparation, metrics, closed);
     const configuration = command.configuration;
-    const configOptions = configuration === void 0 ? prepared.configOptions : await metrics.measure(
+    const snapshot = configuration === void 0 ? prepared : await metrics.measure(
       "configuration",
       async () => await sessions.configureSession({
         ...preparation,
@@ -100440,7 +100570,8 @@ async function prepareSession(command, recovery, closed, config2, resolveAgent,
       agentVersion: prepared.agentVersion,
       capabilities: prepared.capabilities,
       commands: prepared.commands,
-      configOptions,
+      configOptions: snapshot.configOptions,
+      configurationRevision: snapshot.configurationRevision,
       directoryId: command.directoryId,
       directoryLabel: resolved.directoryLabel,
       kind: "session.ready",
@@ -100573,11 +100704,12 @@ async function executeSessionConfigure(socket, command, config2, resolveAgent, d
       command.additionalDirectoryIds,
       signal
     );
-    const configOptions = await sessions.configureSession({
+    const snapshot = await sessions.configureSession({
       additionalDirectories: resolved.additionalDirectories,
       ...await resolveAgent(command.agentId, signal, command.sessionId),
       booleanValue: command.booleanValue,
       configId: command.configId,
+      ...command.expectedConfigurationRevision === void 0 ? {} : { expectedConfigurationRevision: command.expectedConfigurationRevision },
       cwd: resolved.cwd,
       requestId: command.requestId,
       sessionId: command.sessionId,
@@ -100586,7 +100718,7 @@ async function executeSessionConfigure(socket, command, config2, resolveAgent, d
       valueType: command.valueType
     });
     send(socket, {
-      configOptions,
+      ...snapshot,
       kind: "session.config.updated",
       requestId: command.requestId,
       sessionId: command.sessionId
@@ -100634,6 +100766,7 @@ async function executeSessionConfigRead(socket, command, config2, resolveAgent,
     );
     send(socket, {
       configOptions: ready.configOptions,
+      configurationRevision: ready.configurationRevision,
       kind: SESSION_CONFIG_READ_RESULT_KIND,
       requestId: command.requestId,
       sessionId: command.sessionId
@@ -100757,6 +100890,7 @@ var init_session5 = __esm({
 
 // src/runtime/command/registry/index.ts
 function createCommandRegistry(context) {
+  const contentWrites = createContentWriteCommands(context);
   const commands = [
     runtimeDiagnosticsCommand,
     runtimePingCommand,
@@ -100765,6 +100899,7 @@ function createCommandRegistry(context) {
     ...createNativeSessionCommands(context),
     ...createAgentCatalogCommands(context),
     ...createAgentSettingsCommands(context),
+    ...contentWrites.commands,
     fileReadCommand,
     sessionCancelCommand,
     sessionCloseCommand,
@@ -100787,16 +100922,22 @@ function createCommandRegistry(context) {
       }
       command.handle(context, message);
     },
+    dispatchChunk: (message) => contentWrites.receiveChunk(decodeContentChunkFrame(message)),
     settle: async () => {
-      await Promise.all(commands.flatMap((command) => command.settle === void 0 ? [] : [command.settle()]));
+      await Promise.all([
+        contentWrites.settle(),
+        ...commands.flatMap((command) => command.settle === void 0 ? [] : [command.settle()])
+      ]);
     }
   };
 }
 var init_registry2 = __esm({
   "src/runtime/command/registry/index.ts"() {
     "use strict";
+    init_protocol();
     init_agent_catalog();
     init_agent_settings();
+    init_content_write();
     init_file_read();
     init_history3();
     init_interactions2();
@@ -100863,6 +101004,7 @@ function connectRelay(url2, signal) {
       dispatcher,
       headers
     });
+    socket.binaryType = "arraybuffer";
     let released = false;
     const release = (reason) => {
       if (released) {
@@ -101254,7 +101396,16 @@ async function runRelayConnection({
       const handleMessage = (event) => {
         const encoded = event.data;
         if (typeof encoded !== "string") {
-          failAndClose(new Error("Relay sent a non-text message"), 4003, "Text message required", "protocol");
+          try {
+            commands.dispatchChunk(encoded);
+          } catch (error62) {
+            failAndClose(
+              new Error("Relay sent an invalid content chunk", { cause: error62 }),
+              4008,
+              "Invalid content chunk",
+              "protocol"
+            );
+          }
           return;
         }
         try {