@qwen-code/qwen-code 0.21.13 → 0.21.14-nightly.20260822.7a4566cb3b

package/chunks/{daemon-2KTG7ZBN.js → daemon-NNCQ3HWT.js}

@@ -1418,6 +1418,18 @@ var DaemonClient = class {
       { method: "PUT", body: { state }, clientId, mode: "rest" }
     );
   }
+  async setExtensionDefaultActivations(extensionNames, state, clientId) {
+    return await this.jsonRequest(
+      "/extensions/activation",
+      "PUT /extensions/activation",
+      {
+        method: "PUT",
+        body: { extensionNames: [...extensionNames], state },
+        clientId,
+        mode: "rest"
+      }
+    );
+  }
   async extensionOperation(operationId, signal) {
     return await this.jsonRequest(
       `/extensions/operations/${urlEncode(operationId)}`,
@@ -2198,6 +2210,22 @@ var DaemonClient = class {
       "GET /workspace/sessions"
     );
   }
+  /**
+   * Read the memory-only live-state snapshot for a workspace via
+   * `GET /workspaces/:workspace/sessions/live-state`: the complete set of
+   * live sessions with volatile state plus the in-memory catalog version
+   * equality token. Always uses native REST transport (never the pluggable
+   * ACP transport).
+   *
+   * This method deliberately does not pre-flight
+   * `requireCapability('workspace_session_live_state')` — a capability
+   * probe on every poll would double request volume. Consumers preflight
+   * the capability once from their already-loaded capabilities and fall
+   * back to the full session catalog when it is absent.
+   */
+  getWorkspaceSessionLiveState(workspaceCwd, opts = {}) {
+    return this.workspaceByCwd(workspaceCwd).getSessionLiveState(opts);
+  }
   async listSessionGroups(workspaceCwd) {
     return await this.jsonRequest(
       `/workspace/${urlEncode(workspaceCwd)}/session-groups`,
@@ -2425,20 +2453,25 @@ var DaemonClient = class {
       }
     );
   }
-  async sessionGoalClear(sessionId, clientId) {
-    return await this.fetchWithTimeout(
-      `${this.baseUrl}/session/${urlEncode(sessionId)}/goal/clear`,
-      {
-        method: "POST",
-        headers: this.headers({ "Content-Type": "application/json" }, clientId),
-        body: JSON.stringify({})
-      },
-      async (res) => {
-        if (!res.ok) {
-          throw await this.failOnError(res, "POST /session/:id/goal/clear");
-        }
-        return await res.json();
-      }
+  sessionGoalClear(sessionId, clientId) {
+    return this.jsonRequest(
+      `/session/${urlEncode(sessionId)}/goal/clear`,
+      "POST /session/:id/goal/clear",
+      { method: "POST", body: {}, clientId }
+    );
+  }
+  sessionGoal(sessionId, clientId) {
+    return this.jsonRequest(
+      `/session/${urlEncode(sessionId)}/goal`,
+      "GET /session/:id/goal",
+      { clientId }
+    );
+  }
+  sessionGoalControl(sessionId, request, clientId) {
+    return this.jsonRequest(
+      `/session/${urlEncode(sessionId)}/goal`,
+      "POST /session/:id/goal",
+      { method: "POST", body: request, clientId }
     );
   }
   async sessionStats(sessionId, clientId) {
@@ -2644,11 +2677,79 @@ var DaemonClient = class {
     if (!res.ok) throw await this.failOnError(res, "POST /session/:id/btw");
     return await res.json();
   }
+  async uploadSessionAttachment(sessionId, data, name, mimeType, opts) {
+    return await this.fetchWithTimeout(
+      `${this.baseUrl}/session/${urlEncode(sessionId)}/attachments?name=${urlEncode(name)}`,
+      {
+        method: "POST",
+        headers: this.headers({ "Content-Type": mimeType }, opts?.clientId),
+        body: data,
+        signal: opts?.signal
+      },
+      async (res) => {
+        if (!res.ok) {
+          throw await this.failOnError(res, "POST /session/:id/attachments");
+        }
+        return await res.json();
+      }
+    );
+  }
+  async readSessionAttachment(sessionId, attachmentId, opts) {
+    return await this.fetchWithTimeout(
+      `${this.baseUrl}/session/${urlEncode(sessionId)}/attachments/${urlEncode(attachmentId)}`,
+      {
+        method: "GET",
+        headers: this.headers({}, opts?.clientId),
+        signal: opts?.signal
+      },
+      async (res) => {
+        if (!res.ok) {
+          throw await this.failOnError(
+            res,
+            "GET /session/:id/attachments/:attachmentId"
+          );
+        }
+        const bytes = new Uint8Array(await res.arrayBuffer());
+        let binary = "";
+        for (let offset = 0; offset < bytes.length; offset += 32768) {
+          binary += String.fromCharCode(
+            ...bytes.subarray(offset, offset + 32768)
+          );
+        }
+        return {
+          data: btoa(binary),
+          mimeType: res.headers.get("content-type") ?? "application/octet-stream"
+        };
+      }
+    );
+  }
+  async removeSessionAttachment(sessionId, attachmentId, opts) {
+    return await this.fetchWithTimeout(
+      `${this.baseUrl}/session/${urlEncode(sessionId)}/attachments/${urlEncode(attachmentId)}`,
+      {
+        method: "DELETE",
+        headers: this.headers({}, opts?.clientId),
+        signal: opts?.signal
+      },
+      async (res) => {
+        if (!res.ok) {
+          throw await this.failOnError(
+            res,
+            "DELETE /session/:id/attachments/:attachmentId"
+          );
+        }
+        return (await res.json()).removed === true;
+      }
+    );
+  }
   /**
    * Queue a user message typed while the session's turn is still running. The
    * ACP child drains it between tool batches so the model sees it before the
    * turn ends. Every accepted request is daemon-owned; a caller-supplied id
-   * makes ambiguous retries idempotent.
+   * makes ambiguous retries idempotent. `opts.content` carries media content
+   * image blocks alongside the text — pre-flight the
+   * `session_attachments` capability; older daemons ignore the
+   * field and drop the media.
    */
   async enqueueMidTurnMessage(sessionId, message, opts) {
     return await this.fetchWithTimeout(
@@ -2659,7 +2760,11 @@ var DaemonClient = class {
           { "Content-Type": "application/json" },
           opts?.clientId
         ),
-        body: JSON.stringify({ message, messageId: opts?.messageId }),
+        body: JSON.stringify({
+          message,
+          messageId: opts?.messageId,
+          ...opts?.content && opts.content.length > 0 ? { content: opts.content } : {}
+        }),
         signal: opts?.signal
       },
       async (res) => {
@@ -4595,6 +4700,26 @@ var WorkspaceDaemonClient = class {
   getWorkspaceSessionInfo() {
     return this.get("/session-info", "GET /workspaces/:workspace/session-info");
   }
+  /**
+   * Read the memory-only live-state snapshot for this workspace: the
+   * complete set of live sessions with volatile state plus the in-memory
+   * catalog version equality token. Always uses native REST transport
+   * (never the pluggable ACP transport).
+   *
+   * This method deliberately does not pre-flight
+   * `requireCapability('workspace_session_live_state')` — a capability
+   * probe on every poll would double request volume. Consumers preflight
+   * the capability once from their already-loaded capabilities and fall
+   * back to the full session catalog when it is absent.
+   */
+  getSessionLiveState(opts = {}) {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      "/sessions/live-state",
+      "GET /workspaces/:workspace/sessions/live-state",
+      { clientId: opts.clientId, timeoutMs: opts.timeoutMs, mode: "rest" }
+    );
+  }
   /**
    * Read one page from an active persisted session transcript in this
    * workspace.
@@ -4625,6 +4750,14 @@ var WorkspaceDaemonClient = class {
       opts
     );
   }
+  updateSessionMetadata(sessionId, metadata, clientId) {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      `/session/${urlEncode(sessionId)}/metadata`,
+      "PATCH /workspaces/:workspace/session/:id/metadata",
+      { method: "PATCH", body: metadata, clientId, mode: "rest" }
+    );
+  }
   listSessionGroups() {
     return this.get(
       "/session-groups",
@@ -4879,6 +5012,19 @@ var WorkspaceDaemonClient = class {
       { method: "PUT", body: { state }, clientId, mode: "rest" }
     );
   }
+  setExtensionActivations(extensionNames, state, clientId) {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      "/extensions/activation",
+      "PUT /workspaces/:workspace/extensions/activation",
+      {
+        method: "PUT",
+        body: { extensionNames: [...extensionNames], state },
+        clientId,
+        mode: "rest"
+      }
+    );
+  }
   clearExtensionActivation(extensionId, clientId) {
     return this.client.workspaceJsonRequest(
       this.workspaceSelector,
@@ -4983,6 +5129,14 @@ __name(isNonBlockingAccepted, "isNonBlockingAccepted");
 
 // packages/sdk-typescript/src/daemon/DaemonSessionClient.ts
 init_esbuild_shims();
+function isSessionAttachmentReference(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return (record["type"] === "image" || record["type"] === "resource") && typeof record["attachmentId"] === "string" && record["attachmentId"].length > 0 && typeof record["mimeType"] === "string" && record["mimeType"].length > 0 && (record["type"] !== "image" || record["mimeType"].startsWith("image/")) && typeof record["size"] === "number" && Number.isSafeInteger(record["size"]) && record["size"] >= 0 && (record["type"] !== "image" || record["size"] > 0);
+}
+__name(isSessionAttachmentReference, "isSessionAttachmentReference");
+var MAX_ATTACHMENT_CACHE_BYTES = 32 * 1024 * 1024;
+var MAX_ATTACHMENT_CACHE_ENTRIES = 128;
 var DaemonSessionClient = class _DaemonSessionClient {
   static {
     __name(this, "DaemonSessionClient");
@@ -4990,6 +5144,12 @@ var DaemonSessionClient = class _DaemonSessionClient {
   client;
   session;
   state;
+  /**
+   * Not `readonly`: {@link consumeReplaySnapshot} swaps it for an empty
+   * snapshot once the provider has injected it into the transcript store,
+   * releasing the raw wire events (tens of MiB on busy sessions) instead of
+   * retaining them for the session client's lifetime.
+   */
   replaySnapshot;
   replaySnapshotComplete;
   replayPartial;
@@ -5024,6 +5184,8 @@ var DaemonSessionClient = class _DaemonSessionClient {
   reattaching;
   cancelling;
   promptLimit;
+  attachmentCache = /* @__PURE__ */ new Map();
+  attachmentCacheBytes = 0;
   _pendingPrompts = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.client = opts.client;
@@ -5083,7 +5245,7 @@ var DaemonSessionClient = class _DaemonSessionClient {
       eventEpoch,
       ...session
     } = restored;
-    return new _DaemonSessionClient({
+    const result = new _DaemonSessionClient({
       client,
       session,
       hasActivePrompt,
@@ -5101,6 +5263,8 @@ var DaemonSessionClient = class _DaemonSessionClient {
       historyAnchorRecordId,
       replayDegraded
     });
+    await result.hydrateReplaySnapshot();
+    return result;
   }
   /**
    * Resumes an existing daemon session without requesting history replay.
@@ -5149,6 +5313,18 @@ var DaemonSessionClient = class _DaemonSessionClient {
   get eventEpoch() {
     return this.lastSeenEpoch;
   }
+  /**
+   * Returns the retained replay snapshot and drops the client's reference
+   * to it. Call once the snapshot has been injected into a transcript
+   * store; the raw wire events are no longer needed (SSE continues from
+   * `lastEventId`, and older history is served by pagination) and can
+   * otherwise pin tens of MiB per session client.
+   */
+  consumeReplaySnapshot() {
+    const snapshot = this.replaySnapshot;
+    this.replaySnapshot = { compactedReplay: [], liveJournal: [] };
+    return snapshot;
+  }
   setLastEventId(lastEventId) {
     this.lastSeenEventId = validateLastEventId(lastEventId);
   }
@@ -5233,6 +5409,42 @@ var DaemonSessionClient = class _DaemonSessionClient {
     }
     return accepted;
   }
+  async uploadAttachment(data, name, mimeType, signal) {
+    return await this.withClientIdSelfHeal(
+      () => this.client.uploadSessionAttachment(
+        this.sessionId,
+        data,
+        name,
+        mimeType,
+        {
+          ...signal ? { signal } : {},
+          ...this.clientId ? { clientId: this.clientId } : {}
+        }
+      )
+    );
+  }
+  async readAttachment(attachmentId, signal) {
+    return await this.withClientIdSelfHeal(
+      () => this.client.readSessionAttachment(this.sessionId, attachmentId, {
+        ...signal ? { signal } : {},
+        ...this.clientId ? { clientId: this.clientId } : {}
+      })
+    );
+  }
+  async removeAttachment(attachmentId, signal) {
+    const removed = await this.withClientIdSelfHeal(
+      () => this.client.removeSessionAttachment(this.sessionId, attachmentId, {
+        ...signal ? { signal } : {},
+        ...this.clientId ? { clientId: this.clientId } : {}
+      })
+    );
+    if (removed) {
+      const cached = this.attachmentCache.get(attachmentId);
+      this.attachmentCache.delete(attachmentId);
+      this.attachmentCacheBytes -= cached?.size ?? 0;
+    }
+    return removed;
+  }
   /**
    * Run a prompt-admission call, recovering from a stale `clientId`.
    *
@@ -5287,55 +5499,48 @@ var DaemonSessionClient = class _DaemonSessionClient {
    * policy. Forwards the bound `clientId` so identified clients update
    * their per-client timestamp instead of just the session-wide one.
    */
-  async heartbeat() {
-    return await this.client.heartbeat(this.sessionId, this.clientId);
+  heartbeat() {
+    return this.client.heartbeat(this.sessionId, this.clientId);
   }
-  async artifacts() {
-    return await this.client.listSessionArtifacts(
-      this.sessionId,
-      this.clientId
-    );
+  artifacts() {
+    return this.client.listSessionArtifacts(this.sessionId, this.clientId);
   }
-  async addArtifact(artifact) {
-    return await this.client.addSessionArtifact(
+  addArtifact(artifact) {
+    return this.client.addSessionArtifact(
       this.sessionId,
       artifact,
       this.clientId
     );
   }
-  async removeArtifact(artifactId) {
-    return await this.client.removeSessionArtifact(
+  removeArtifact(artifactId) {
+    return this.client.removeSessionArtifact(
       this.sessionId,
       artifactId,
       this.clientId
     );
   }
-  async setModel(modelId) {
-    return await this.client.setSessionModel(
-      this.sessionId,
-      modelId,
-      this.clientId
-    );
+  setModel(modelId) {
+    return this.client.setSessionModel(this.sessionId, modelId, this.clientId);
   }
-  async setConfigOption(configId, value) {
-    return await this.client.setSessionConfigOption(
+  setConfigOption(configId, value) {
+    return this.client.setSessionConfigOption(
       this.sessionId,
       configId,
       value,
       this.clientId
     );
   }
-  async getRewindSnapshots() {
-    return await this.client.getRewindSnapshots(this.sessionId);
+  getRewindSnapshots() {
+    return this.client.getRewindSnapshots(this.sessionId);
   }
-  async rewind(promptId, opts) {
-    return await this.client.rewindSession(this.sessionId, promptId, {
+  rewind(promptId, opts) {
+    return this.client.rewindSession(this.sessionId, promptId, {
       clientId: this.clientId,
       ...opts?.rewindFiles !== void 0 ? { rewindFiles: opts.rewindFiles } : {}
     });
   }
-  async fork(directive) {
-    return await this.client.forkSession(
+  fork(directive) {
+    return this.client.forkSession(
       this.sessionId,
       { directive },
       this.clientId
@@ -5349,8 +5554,8 @@ var DaemonSessionClient = class _DaemonSessionClient {
    * child both run to completion regardless (no cross-process abort
    * plumbing in v1).
    */
-  async recap(opts) {
-    return await this.client.recapSession(this.sessionId, {
+  recap(opts) {
+    return this.client.recapSession(this.sessionId, {
       ...opts?.signal ? { signal: opts.signal } : {},
       ...this.clientId ? { clientId: this.clientId } : {}
     });
@@ -5361,8 +5566,8 @@ var DaemonSessionClient = class _DaemonSessionClient {
       ...this.clientId ? { clientId: this.clientId } : {}
     });
   }
-  async btw(question, opts) {
-    return await this.client.btwSession(this.sessionId, question, {
+  btw(question, opts) {
+    return this.client.btwSession(this.sessionId, question, {
       ...opts?.signal ? { signal: opts.signal } : {},
       ...this.clientId ? { clientId: this.clientId } : {}
     });
@@ -5373,15 +5578,16 @@ var DaemonSessionClient = class _DaemonSessionClient {
    * create/attach. Accepted requests become daemon-owned even when the active
    * turn settles while the request is in flight.
    */
-  async enqueueMidTurnMessage(message, opts) {
-    return await this.client.enqueueMidTurnMessage(this.sessionId, message, {
+  enqueueMidTurnMessage(message, opts) {
+    return this.client.enqueueMidTurnMessage(this.sessionId, message, {
       ...opts?.signal ? { signal: opts.signal } : {},
       ...opts?.messageId ? { messageId: opts.messageId } : {},
+      ...opts?.content && opts.content.length > 0 ? { content: opts.content } : {},
       ...this.clientId ? { clientId: this.clientId } : {}
     });
   }
-  async removeMidTurnMessage(messageId) {
-    return await this.client.removeMidTurnMessage(this.sessionId, messageId, {
+  removeMidTurnMessage(messageId) {
+    return this.client.removeMidTurnMessage(this.sessionId, messageId, {
       ...this.clientId ? { clientId: this.clientId } : {}
     });
   }
@@ -5393,18 +5599,47 @@ var DaemonSessionClient = class _DaemonSessionClient {
    * callers preserve their current state.
    */
   async getMidTurnMessages(opts) {
-    return await this.client.getMidTurnMessages(this.sessionId, {
+    const result = await this.client.getMidTurnMessages(this.sessionId, {
       ...opts?.signal ? { signal: opts.signal } : {},
       ...this.clientId ? { clientId: this.clientId } : {}
     });
+    return {
+      ...result,
+      messages: await Promise.all(
+        result.messages.map(async (message) => ({
+          ...message,
+          ...message.content ? { content: await this.hydrateContent(message.content) } : {}
+        }))
+      )
+    };
   }
   async getPendingPrompts() {
-    return await this.client.getPendingPrompts(this.sessionId, {
+    const result = await this.client.getPendingPrompts(this.sessionId, {
       ...this.clientId ? { clientId: this.clientId } : {}
     });
+    return {
+      pendingPrompts: await Promise.all(
+        result.pendingPrompts.map(async (prompt) => ({
+          ...prompt,
+          ...prompt.content ? { content: await this.hydrateContent(prompt.content) } : {}
+        }))
+      )
+    };
+  }
+  async getTranscriptPage(opts = {}) {
+    const page = await this.client.getSessionTranscriptPage(this.sessionId, {
+      ...opts,
+      clientId: opts.clientId ?? this.clientId
+    });
+    return {
+      ...page,
+      events: await Promise.all(
+        page.events.map(async (event) => await this.hydrateEvent(event))
+      )
+    };
   }
-  async removePendingPrompt(promptId) {
-    return await this.client.removePendingPrompt(this.sessionId, promptId, {
+  removePendingPrompt(promptId) {
+    return this.client.removePendingPrompt(this.sessionId, promptId, {
       ...this.clientId ? { clientId: this.clientId } : {}
     });
   }
@@ -5414,50 +5649,53 @@ var DaemonSessionClient = class _DaemonSessionClient {
    * automatically forwards the client id bound when the session was created
    * or attached.
    */
-  async shellCommand(command, signal) {
-    return await this.client.shellCommand(this.sessionId, command, {
+  shellCommand(command, signal) {
+    return this.client.shellCommand(this.sessionId, command, {
       ...signal ? { signal } : {},
       ...this.clientId ? { clientId: this.clientId } : {}
     });
   }
-  async context() {
-    return await this.client.sessionContext(this.sessionId, this.clientId);
+  context() {
+    return this.client.sessionContext(this.sessionId, this.clientId);
   }
-  async status() {
-    return await this.client.sessionStatus(this.sessionId, this.clientId);
+  status() {
+    return this.client.sessionStatus(this.sessionId, this.clientId);
   }
-  async contextUsage(opts = {}) {
-    return await this.client.sessionContextUsage(
-      this.sessionId,
-      opts,
-      this.clientId
-    );
+  contextUsage(opts = {}) {
+    return this.client.sessionContextUsage(this.sessionId, opts, this.clientId);
   }
-  async supportedCommands() {
-    return await this.client.sessionSupportedCommands(
-      this.sessionId,
-      this.clientId
-    );
+  supportedCommands() {
+    return this.client.sessionSupportedCommands(this.sessionId, this.clientId);
   }
-  async tasks() {
-    return await this.client.sessionTasks(this.sessionId, this.clientId);
+  tasks() {
+    return this.client.sessionTasks(this.sessionId, this.clientId);
   }
-  async lspStatus() {
-    return await this.client.sessionLspStatus(this.sessionId, this.clientId);
+  lspStatus() {
+    return this.client.sessionLspStatus(this.sessionId, this.clientId);
   }
-  async cancelTask(taskId, kind) {
-    return await this.client.sessionTaskCancel(
+  cancelTask(taskId, kind) {
+    return this.client.sessionTaskCancel(
       this.sessionId,
       taskId,
       kind,
       this.clientId
     );
   }
-  async clearGoal() {
-    return await this.client.sessionGoalClear(this.sessionId, this.clientId);
+  clearGoal() {
+    return this.client.sessionGoalClear(this.sessionId, this.clientId);
+  }
+  goal() {
+    return this.client.sessionGoal(this.sessionId, this.clientId);
+  }
+  controlGoal(request) {
+    return this.client.sessionGoalControl(
+      this.sessionId,
+      request,
+      this.clientId
+    );
   }
-  async stats() {
-    return await this.client.sessionStats(this.sessionId, this.clientId);
+  stats() {
+    return this.client.sessionStats(this.sessionId, this.clientId);
   }
   async respondToPermission(requestId, response) {
     return await this.client.respondToPermission(
@@ -5581,8 +5819,9 @@ var DaemonSessionClient = class _DaemonSessionClient {
           callerOnEpoch?.(learned);
         }, "onEpoch")
       })) {
-        this._dispatchTurnEvent(event);
-        yield event;
+        const hydratedEvent = await this.hydrateEvent(event);
+        this._dispatchTurnEvent(hydratedEvent);
+        yield hydratedEvent;
         if (event.id !== void 0) {
           this.lastSeenEventId = Math.max(
             this.lastSeenEventId ?? 0,
@@ -5595,6 +5834,113 @@ var DaemonSessionClient = class _DaemonSessionClient {
       release();
     }
   }
+  async hydrateReplaySnapshot() {
+    this.replaySnapshot.compactedReplay = await Promise.all(
+      this.replaySnapshot.compactedReplay.map(
+        async (event) => await this.hydrateEvent(event)
+      )
+    );
+    this.replaySnapshot.liveJournal = await Promise.all(
+      this.replaySnapshot.liveJournal.map(
+        async (event) => await this.hydrateEvent(event)
+      )
+    );
+  }
+  async hydrateEvent(event) {
+    if (!event.data || typeof event.data !== "object") return event;
+    const data = event.data;
+    if (event.type === "session_update") {
+      const update = data["update"];
+      if (update && typeof update === "object" && !Array.isArray(update)) {
+        const content2 = update["content"];
+        const hydrated2 = await this.hydrateBlock(content2);
+        if (hydrated2 === content2) return event;
+        return {
+          ...event,
+          data: { ...data, update: { ...update, content: hydrated2 } }
+        };
+      }
+      const content = data["content"];
+      const hydrated = await this.hydrateBlock(content);
+      if (hydrated === content) return event;
+      return { ...event, data: { ...data, content: hydrated } };
+    }
+    if (event.type !== "mid_turn_message_injected") return event;
+    const items = data["items"];
+    if (!Array.isArray(items)) return event;
+    return {
+      ...event,
+      data: {
+        ...data,
+        items: await Promise.all(
+          items.map(async (item) => {
+            if (!item || typeof item !== "object" || Array.isArray(item)) {
+              return item;
+            }
+            const record = item;
+            return Array.isArray(record["content"]) ? {
+              ...record,
+              content: await this.hydrateContent(record["content"])
+            } : item;
+          })
+        )
+      }
+    };
+  }
+  async hydrateContent(content) {
+    return await Promise.all(
+      content.map(async (block) => await this.hydrateBlock(block))
+    );
+  }
+  async hydrateBlock(block) {
+    if (!isSessionAttachmentReference(block)) {
+      return block;
+    }
+    if (block.type === "resource") return block;
+    let cached = this.attachmentCache.get(block.attachmentId);
+    if (cached) {
+      this.attachmentCache.delete(block.attachmentId);
+      this.attachmentCache.set(block.attachmentId, cached);
+    } else {
+      const pending = this.withClientIdSelfHeal(
+        () => this.client.readSessionAttachment(this.sessionId, block.attachmentId, {
+          ...this.clientId ? { clientId: this.clientId } : {}
+        })
+      );
+      cached = { pending, size: block.size };
+      this.attachmentCache.set(block.attachmentId, cached);
+      this.attachmentCacheBytes += block.size;
+      while (this.attachmentCache.size > MAX_ATTACHMENT_CACHE_ENTRIES || this.attachmentCacheBytes > MAX_ATTACHMENT_CACHE_BYTES) {
+        const oldestId = this.attachmentCache.keys().next().value;
+        if (oldestId === void 0) break;
+        const evicted = this.attachmentCache.get(oldestId);
+        this.attachmentCache.delete(oldestId);
+        this.attachmentCacheBytes -= evicted?.size ?? 0;
+      }
+      void pending.catch(() => {
+        if (this.attachmentCache.get(block.attachmentId)?.pending !== pending)
+          return;
+        this.attachmentCache.delete(block.attachmentId);
+        this.attachmentCacheBytes -= block.size;
+      });
+    }
+    try {
+      const attachment = await cached.pending;
+      return {
+        type: "image",
+        data: attachment.data,
+        mimeType: attachment.mimeType
+      };
+    } catch (err) {
+      if (err instanceof DaemonHttpError && (err.status === 404 || err.status === 410)) {
+        return {
+          type: "text",
+          text: "[Attachment is no longer available]"
+        };
+      }
+      return block;
+    }
+  }
   _dispatchTurnEvent(event) {
     if (event.type !== "turn_complete" && event.type !== "turn_error") return;
     const promptId = event.data?.promptId;
@@ -5931,7 +6277,7 @@ function asKnownDaemonEvent(event) {
     case "tool_toggled":
       return isToolToggledData(event.data) ? event : void 0;
     case "settings_changed":
-      return event.data != null && typeof event.data === "object" ? event : void 0;
+      return isSettingsChangedData(event.data) ? event : void 0;
     case "trust_change_requested":
       return isTrustChangeRequestedData(event.data) ? event : void 0;
     case "workspace_initialized":
@@ -6633,6 +6979,19 @@ function isToolToggledData(value) {
   return isRecord(value) && isNonEmptyString(value["toolName"]) && typeof value["enabled"] === "boolean";
 }
 __name(isToolToggledData, "isToolToggledData");
+function isDaemonSkillToggleMutation(value) {
+  if (!isRecord(value)) return false;
+  const activation = value["activation"];
+  const skills = value["skills"];
+  return isNonEmptyString(value["id"]) && value["kind"] === "skill_toggle" && Array.isArray(skills) && skills.length > 0 && skills.every(
+    (skill) => isRecord(skill) && isNonEmptyString(skill["name"]) && typeof skill["enabled"] === "boolean"
+  ) && (activation === "applied" || activation === "deferred" || activation === "partial") && isFiniteNumber(value["sessionsRefreshed"]) && isFiniteNumber(value["sessionsFailed"]);
+}
+__name(isDaemonSkillToggleMutation, "isDaemonSkillToggleMutation");
+function isSettingsChangedData(value) {
+  return isRecord(value) && isNonEmptyString(value["key"]) && (value["scope"] === void 0 || typeof value["scope"] === "string") && (value["mutation"] === void 0 || isDaemonSkillToggleMutation(value["mutation"]));
+}
+__name(isSettingsChangedData, "isSettingsChangedData");
 function isTrustChangeRequestedData(value) {
   if (!isRecord(value)) return false;
   const desiredState = value["desiredState"];
@@ -6880,6 +7239,16 @@ var DAEMON_UI_DEBUG_REASONS = [
   "unrecognized_session_update",
   "malformed_payload"
 ];
+var DAEMON_UI_UNRECOGNIZED_DIAGNOSTIC_REASONS = [
+  "unrecognized_event",
+  "unrecognized_session_update"
+];
+function isUnrecognizedDiagnosticReason(reason) {
+  return reason !== void 0 && DAEMON_UI_UNRECOGNIZED_DIAGNOSTIC_REASONS.includes(
+    reason
+  );
+}
+__name(isUnrecognizedDiagnosticReason, "isUnrecognizedDiagnosticReason");
 
 // packages/sdk-typescript/src/daemon/ui/utils.ts
 init_esbuild_shims();
@@ -6918,6 +7287,16 @@ function stringifyRedactedJson(value) {
   return stringifyJson(redactSensitiveFields(value));
 }
 __name(stringifyRedactedJson, "stringifyRedactedJson");
+var MAX_DETAILS_LENGTH = 4096;
+function detachString(value) {
+  return new TextDecoder("utf-8").decode(new TextEncoder().encode(value));
+}
+__name(detachString, "detachString");
+function capDetails(details) {
+  if (details.length <= MAX_DETAILS_LENGTH) return details;
+  return `${detachString(details.slice(0, MAX_DETAILS_LENGTH))}... [truncated]`;
+}
+__name(capDetails, "capDetails");
 function redactSensitiveFields(value, depth = 0) {
   if (depth > 16) return "[truncated]";
   if (Array.isArray(value)) {
@@ -7075,8 +7454,8 @@ var MCP_RESTART_REFUSED_REASONS2 = /* @__PURE__ */ new Set([
   "authentication_required"
 ]);
 var MALFORMED_MEMORY_CHANGED = "malformed memory_changed payload";
-var MAX_DETAILS_LENGTH = 4096;
 var SESSION_RECORDING_DEGRADED_MESSAGE = "Session recording stopped after a write failure. New messages for the affected session will not be saved. Check disk space and permissions, then start a new session to resume recording.";
+var ATTACHMENT_UNAVAILABLE_TEXT = "[Attachment is no longer available]";
 function normalizeDaemonEvent(event, opts = {}) {
   const base = createBase(event, opts);
   switch (event.type) {
@@ -7338,7 +7717,10 @@ function normalizeUnrecognizedEvent(event, base) {
       ...base,
       type: "debug",
       debugReason: "unrecognized_event",
-      text: `${event.type} (unrecognized daemon event): ${stringifyRedactedJson(event.data)}`
+      text: debugBlockText(
+        `${event.type} (unrecognized daemon event)`,
+        event.data
+      )
     }
   ];
 }
@@ -7453,21 +7835,37 @@ function normalizeMidTurnMessageInjected(event, base) {
   if (!isRecord2(event.data)) {
     return fallbackDebug(event, base, "malformed mid_turn_message_injected");
   }
-  const messages = Array.isArray(event.data["messages"]) ? event.data["messages"].filter(
-    (message) => typeof message === "string" && message.length > 0
-  ) : [];
-  if (messages.length === 0) {
+  const data = event.data;
+  const rawMessages = data["messages"];
+  const messages = Array.isArray(rawMessages) && rawMessages.every(
+    (message) => typeof message === "string"
+  ) ? rawMessages : [];
+  const items = data["items"];
+  const hasRenderableItemContent = Array.isArray(items) && items.some(
+    (item) => isRecord2(item) && Array.isArray(item["content"]) && item["content"].some(
+      (block) => isRecord2(block) && (block["type"] === "image" || block["type"] === "resource" || block["type"] === "text" && typeof block["text"] === "string" && block["text"].length > 0)
+    )
+  );
+  if (messages.length === 0 || !messages.some(Boolean) && !hasRenderableItemContent) {
     return fallbackDebug(event, base, "malformed mid_turn_message_injected");
   }
-  return [
-    {
+  const messageIds = Array.isArray(data["messageIds"]) ? data["messageIds"] : [];
+  return messages.map((text, index) => {
+    const item = Array.isArray(items) ? items[index] : void 0;
+    const messageId = messageIds[index];
+    return {
       ...base,
       type: "status",
-      text: `Inserted message: ${messages.join("\n")}`,
+      text,
       source: "mid_turn_message_injected",
-      data: event.data
-    }
-  ];
+      data: {
+        ...data,
+        messages: [text],
+        ...Array.isArray(items) ? { items: item !== void 0 ? [item] : [] } : {},
+        ...typeof messageId === "string" ? { messageIds: [messageId] } : Array.isArray(data["messageIds"]) ? { messageIds: [] } : {}
+      }
+    };
+  });
 }
 __name(normalizeMidTurnMessageInjected, "normalizeMidTurnMessageInjected");
 function createBase(event, opts) {
@@ -7540,6 +7938,10 @@ function parseTimestamp(value) {
   return Number.isFinite(parsed) ? parsed : void 0;
 }
 __name(parseTimestamp, "parseTimestamp");
+function isAttachmentReferenceContent(value) {
+  return isRecord2(value) && (value["type"] === "image" || value["type"] === "resource") && typeof value["attachmentId"] === "string" && value["attachmentId"].length > 0 && value["data"] === void 0 && value["url"] === void 0 && value["source"] === void 0;
+}
+__name(isAttachmentReferenceContent, "isAttachmentReferenceContent");
 function normalizeSessionUpdate(event, base, opts) {
   const update = getSessionUpdatePayload(event.data);
   if (!update) {
@@ -7548,7 +7950,7 @@ function normalizeSessionUpdate(event, base, opts) {
         ...base,
         type: "debug",
         debugReason: "malformed_payload",
-        text: `session_update: ${stringifyRedactedJson(event.data)}`
+        text: debugBlockText("session_update", event.data)
       }
     ];
   }
@@ -7574,7 +7976,15 @@ function normalizeSessionUpdate(event, base, opts) {
             else if (prefix.startsWith("UklGR")) mimeType = "image/webp";
           }
           if (data) {
-            return [{ ...base, type: "user.image.delta", data, mimeType }];
+            return [
+              {
+                ...base,
+                type: "user.image.delta",
+                data,
+                mimeType,
+                ...meta ? { meta } : {}
+              }
+            ];
           }
           return [];
         }
@@ -7590,6 +8000,30 @@ function normalizeSessionUpdate(event, base, opts) {
         }
         return [];
       }
+      if (isAttachmentReferenceContent(content)) {
+        if (content["type"] === "resource") {
+          const attachmentId = content["attachmentId"];
+          const mimeType = content["mimeType"];
+          return [
+            {
+              ...base,
+              type: "user.file.delta",
+              name: attachmentId,
+              attachmentId,
+              mimeType: typeof mimeType === "string" ? mimeType : "",
+              ...meta ? { meta } : {}
+            }
+          ];
+        }
+        return [
+          {
+            ...base,
+            type: "user.text.delta",
+            text: ATTACHMENT_UNAVAILABLE_TEXT,
+            ...meta ? { meta } : {}
+          }
+        ];
+      }
       const text = getTextContent(content);
       return text ? [
         {
@@ -7692,7 +8126,7 @@ function normalizeSessionUpdate(event, base, opts) {
           // discriminator is truthy but no more usable than an empty one, so
           // apply the same `trim()` convention `getFirstString` uses.
           debugReason: kind?.trim() ? "unrecognized_session_update" : "malformed_payload",
-          text: `${kind ?? "session_update"}: ${stringifyRedactedJson(update)}`
+          text: debugBlockText(kind ?? "session_update", update)
         }
       ];
   }
@@ -7863,11 +8297,10 @@ function asDaemonErrorKind(value) {
   return DAEMON_ERROR_KIND_SET.has(value) ? value : void 0;
 }
 __name(asDaemonErrorKind, "asDaemonErrorKind");
-function capDetails(details) {
-  if (details.length <= MAX_DETAILS_LENGTH) return details;
-  return `${details.slice(0, MAX_DETAILS_LENGTH)}... [truncated]`;
+function debugBlockText(prefix, data) {
+  return capDetails(`${prefix}: ${stringifyRedactedJson(data)}`);
 }
-__name(capDetails, "capDetails");
+__name(debugBlockText, "debugBlockText");
 function normalizePermissionRequest(event, base) {
   if (!isRecord2(event.data)) {
     return [
@@ -7875,7 +8308,7 @@ function normalizePermissionRequest(event, base) {
         ...base,
         type: "debug",
         debugReason: "malformed_payload",
-        text: `permission_request: ${stringifyRedactedJson(event.data)}`
+        text: debugBlockText("permission_request", event.data)
       }
     ];
   }
@@ -7886,7 +8319,7 @@ function normalizePermissionRequest(event, base) {
         ...base,
         type: "debug",
         debugReason: "malformed_payload",
-        text: `permission_request: ${stringifyRedactedJson(event.data)}`
+        text: debugBlockText("permission_request", event.data)
       }
     ];
   }
@@ -7912,7 +8345,7 @@ function normalizePermissionResolved(event, base) {
         ...base,
         type: "debug",
         debugReason: "malformed_payload",
-        text: `${event.type}: ${stringifyRedactedJson(event.data)}`
+        text: debugBlockText(event.type, event.data)
       }
     ];
   }
@@ -8128,13 +8561,15 @@ function normalizeSettingsChanged(event, base) {
   if (!key) {
     return fallbackDebug(event, base, "malformed settings_changed payload");
   }
+  const mutation = isSettingsChangedData(event.data) && event.data.mutation;
   return [
     {
       ...base,
       type: "workspace.settings.changed",
       key,
       scope: scope ?? "workspace",
-      value: isRecord2(event.data) ? event.data["value"] : void 0
+      value: isRecord2(event.data) ? event.data["value"] : void 0,
+      ...mutation ? { mutation } : {}
     }
   ];
 }
@@ -8699,7 +9134,7 @@ function collectPreviewRows(input) {
     if (isRecord2(value)) continue;
     rows.push({
       label: key,
-      value: isSensitiveKey(key) ? "[redacted]" : stringifyRedactedJson(value)
+      value: isSensitiveKey(key) ? "[redacted]" : capDetails(stringifyRedactedJson(value))
     });
   }
   return rows;
@@ -8862,8 +9297,18 @@ __name(detectTabular, "detectTabular");
 // packages/sdk-typescript/src/daemon/ui/transcript.ts
 init_esbuild_shims();
 var DEFAULT_MAX_BLOCKS = 1e3;
+var DEFAULT_MAX_RETAINED_BYTES = 128 * 1024 * 1024;
+var UNRECOGNIZED_DIAGNOSTICS_LIMIT = 50;
 var TRIMMED_TOOL_BLOCK_ID = "__trimmed_tool_block__";
 var TRIMMED_PERMISSION_BLOCK_ID = "__trimmed_permission_block__";
+function isTrimmedToolBlockId(blockId) {
+  return blockId === TRIMMED_TOOL_BLOCK_ID;
+}
+__name(isTrimmedToolBlockId, "isTrimmedToolBlockId");
+function isTrimmedPermissionBlockId(blockId) {
+  return blockId === TRIMMED_PERMISSION_BLOCK_ID;
+}
+__name(isTrimmedPermissionBlockId, "isTrimmedPermissionBlockId");
 var MAX_TEXT_BLOCK_LENGTH = 1e5;
 var TEXT_TRUNCATED_SUFFIX = "\n[truncated]\n";
 var MAX_CLONE_DEPTH = 16;
@@ -8880,11 +9325,14 @@ function createDaemonTranscriptState(opts = {}) {
     activeThoughtBlockByParent: createIndex(),
     // PR-E sidechannel: track current tool / approval mode / progress
     toolProgress: createIndex(),
+    unrecognizedDiagnostics: [],
     awaitingResync: false,
     resyncRequiredCount: 0,
     nextOrdinal: 1,
     now: opts.now ?? Date.now(),
     maxBlocks: opts.maxBlocks ?? DEFAULT_MAX_BLOCKS,
+    retainedBytes: 0,
+    maxRetainedBytes: opts.maxRetainedBytes ?? DEFAULT_MAX_RETAINED_BYTES,
     retainSubagentBlocks: opts.retainSubagentBlocks ?? true
   };
   if (opts.onTruncation) truncationCallbacks.set(state, opts.onTruncation);
@@ -8934,14 +9382,15 @@ function appendLocalUserTranscriptMessage(state, text, opts = {}) {
   return trimTranscriptState(next);
 }
 __name(appendLocalUserTranscriptMessage, "appendLocalUserTranscriptMessage");
-var FREEZE_TRANSCRIPT_BLOCKS = typeof process !== "undefined" && false;
+var FREEZE_TRANSCRIPT_COLLECTIONS = typeof process !== "undefined" && false;
 function reduceDaemonTranscriptEvents(state, events, opts = {}) {
   if (events.length === 0) return state;
   const next = cloneTranscriptState(state, opts);
   for (const event of events) applyDaemonTranscriptEvent(next, event);
   const result = trimTranscriptState(next);
-  if (FREEZE_TRANSCRIPT_BLOCKS) {
+  if (FREEZE_TRANSCRIPT_COLLECTIONS) {
     Object.freeze(result.blocks);
+    Object.freeze(result.blockIndexById);
   }
   return result;
 }
@@ -8954,6 +9403,28 @@ function rebuildDaemonTranscriptBlockIndex(blocks) {
   return blockIndexById;
 }
 __name(rebuildDaemonTranscriptBlockIndex, "rebuildDaemonTranscriptBlockIndex");
+function userBlockForAttachment(next, event) {
+  const activeUserIndex = next.activeUserBlockId ? next.blockIndexById[next.activeUserBlockId] : void 0;
+  const activeUser = activeUserIndex !== void 0 ? next.blocks[activeUserIndex] : void 0;
+  if (activeUser?.kind === "user" && stringArraysEqual(activeUser.sourceRecordIds, event.sourceRecordIds)) {
+    const block2 = getWritableBlockById(next, activeUser.id);
+    if (block2?.kind === "user") return block2;
+  }
+  const block = createTextBlock(
+    next,
+    "user",
+    "",
+    event.eventId,
+    event.serverTimestamp,
+    event.meta,
+    event.sourceRecordIds,
+    event.promptId
+  );
+  appendBlock(next, block);
+  next.activeUserBlockId = block.id;
+  return block;
+}
+__name(userBlockForAttachment, "userBlockForAttachment");
 function applyDaemonTranscriptEvent(next, event) {
   if (event.eventId !== void 0) {
     next.lastEventId = Math.max(next.lastEventId ?? 0, event.eventId);
@@ -8980,31 +9451,29 @@ function applyDaemonTranscriptEvent(next, event) {
       appendTextDelta(next, "user", "activeUserBlockId", event.text, event);
       break;
     case "user.image.delta": {
-      const activeUserIndex = next.activeUserBlockId ? next.blockIndexById[next.activeUserBlockId] : void 0;
-      const activeUser = activeUserIndex !== void 0 ? next.blocks[activeUserIndex] : void 0;
-      if (activeUser?.kind !== "user" || !stringArraysEqual(activeUser.sourceRecordIds, event.sourceRecordIds)) {
-        const block = createTextBlock(
-          next,
-          "user",
-          "",
-          event.eventId,
-          event.serverTimestamp,
-          void 0,
-          event.sourceRecordIds,
-          event.promptId
-        );
-        block.images = [{ data: event.data, mimeType: event.mimeType }];
-        appendBlock(next, block);
-        next.activeUserBlockId = block.id;
-      } else {
-        const block = getWritableBlockById(next, next.activeUserBlockId);
-        if (block && block.kind === "user") {
-          block.images = [
-            ...block.images ?? [],
-            { data: event.data, mimeType: event.mimeType }
-          ];
+      const block = userBlockForAttachment(next, event);
+      const bytesBefore = estimateBlockBytes(block);
+      if (event.meta) block.meta = { ...block.meta, ...event.meta };
+      block.images = [
+        ...block.images ?? [],
+        { data: event.data, mimeType: event.mimeType }
+      ];
+      next.retainedBytes += estimateBlockBytes(block) - bytesBefore;
+      break;
+    }
+    case "user.file.delta": {
+      const fileBlock = userBlockForAttachment(next, event);
+      const fileBytesBefore = estimateBlockBytes(fileBlock);
+      if (event.meta) fileBlock.meta = { ...fileBlock.meta, ...event.meta };
+      fileBlock.files = [
+        ...fileBlock.files ?? [],
+        {
+          name: event.name,
+          mimeType: event.mimeType,
+          attachmentId: event.attachmentId
         }
-      }
+      ];
+      next.retainedBytes += estimateBlockBytes(fileBlock) - fileBytesBefore;
       break;
     }
     case "assistant.text.delta":
@@ -9082,6 +9551,10 @@ function applyDaemonTranscriptEvent(next, event) {
       break;
     case "status":
     case "debug":
+      if (isUnrecognizedDiagnostic(event)) {
+        appendUnrecognizedDiagnostic(next, event);
+        break;
+      }
       appendStatusBlock(next, event.type, event.text, event, {
         clearActiveText: event.clearActiveText
       });
@@ -9394,6 +9867,9 @@ function upsertToolBlock(state, event) {
     }
     return;
   }
+  const retainedIndex = existingId !== void 0 ? state.blockIndexById[existingId] : void 0;
+  const retainedBefore = retainedIndex !== void 0 ? state.blocks[retainedIndex] : void 0;
+  const bytesBefore = retainedBefore ? estimateBlockBytes(retainedBefore) : 0;
   const existing = getWritableBlockById(state, existingId);
   if (existing?.kind === "tool") {
     if (event.title !== void 0) existing.title = event.title;
@@ -9469,6 +9945,7 @@ function upsertToolBlock(state, event) {
     if (event.subagentType && !existing.subagentType) {
       existing.subagentType = event.subagentType;
     }
+    state.retainedBytes += estimateBlockBytes(existing) - bytesBefore;
     updateCurrentToolPointer(state, event.toolCallId, event.status);
     return;
   }
@@ -9518,9 +9995,19 @@ __name(upsertToolBlock, "upsertToolBlock");
 function discardToolBlock(state, toolCallId) {
   const blockId = state.toolBlockByCallId[toolCallId];
   if (!blockId || blockId === TRIMMED_TOOL_BLOCK_ID) return;
+  const droppedIndex = state.blockIndexById[blockId];
+  const dropped = droppedIndex !== void 0 ? state.blocks[droppedIndex] : void 0;
   takeBlocksOwnership(state);
   state.blocks = state.blocks.filter((block) => block.id !== blockId);
+  if (dropped) {
+    state.retainedBytes = Math.max(
+      0,
+      state.retainedBytes - estimateBlockBytes(dropped)
+    );
+  }
   state.blockIndexById = rebuildDaemonTranscriptBlockIndex(state.blocks);
+  ownedBlocks.set(state, state.blocks);
+  ownedBlockIndexes.set(state, state.blockIndexById);
   delete state.toolBlockByCallId[toolCallId];
   delete state.toolProgress[toolCallId];
   if (state.currentToolCallId === toolCallId) {
@@ -9710,6 +10197,27 @@ function resolvePermissionBlock(state, event) {
   clearActiveText(state);
 }
 __name(resolvePermissionBlock, "resolvePermissionBlock");
+function isUnrecognizedDiagnostic(event) {
+  return event.type === "debug" && isUnrecognizedDiagnosticReason(event.debugReason);
+}
+__name(isUnrecognizedDiagnostic, "isUnrecognizedDiagnostic");
+function appendUnrecognizedDiagnostic(state, event) {
+  state.activeUserBlockId = void 0;
+  const diagnostic = {
+    debugReason: event.debugReason,
+    text: truncateTextAtLimit(event.text),
+    clientReceivedAt: state.now,
+    ...event.promptId !== void 0 ? { promptId: event.promptId } : {},
+    ...event.sourceRecordIds !== void 0 ? { sourceRecordIds: event.sourceRecordIds } : {},
+    ...event.branchRecordId !== void 0 ? { branchRecordId: event.branchRecordId } : {},
+    ...event.originatorClientId !== void 0 ? { originatorClientId: event.originatorClientId } : {},
+    ...event.eventId !== void 0 ? { eventId: event.eventId } : {},
+    ...event.serverTimestamp !== void 0 ? { serverTimestamp: event.serverTimestamp } : {}
+  };
+  const diagnostics = [...state.unrecognizedDiagnostics, diagnostic];
+  state.unrecognizedDiagnostics = diagnostics.length > UNRECOGNIZED_DIAGNOSTICS_LIMIT ? diagnostics.slice(-UNRECOGNIZED_DIAGNOSTICS_LIMIT) : diagnostics;
+}
+__name(appendUnrecognizedDiagnostic, "appendUnrecognizedDiagnostic");
 function appendStatusBlock(state, kind, text, event, opts = {}) {
   const blockId = allocateBlockId(state, kind);
   const block = {
@@ -9779,6 +10287,7 @@ function cloneTranscriptState(state, opts) {
     ...state,
     now: opts.now ?? Date.now(),
     maxBlocks: opts.maxBlocks ?? state.maxBlocks,
+    maxRetainedBytes: opts.maxRetainedBytes ?? state.maxRetainedBytes,
     retainSubagentBlocks: opts.retainSubagentBlocks ?? state.retainSubagentBlocks,
     // Lazy copy-on-write for
     // `blocks` + `blockIndexById`. Eager `[...state.blocks]` defeated the
@@ -9818,21 +10327,62 @@ function cloneTranscriptState(state, opts) {
     // unrelated dispatches lets `useSyncExternalStore` subscribers
     // (e.g. `useDaemonFollowupSuggestion`) skip re-renders for events
     // that don't touch the suggestion.
-    lastFollowupSuggestion: state.lastFollowupSuggestion
+    lastFollowupSuggestion: state.lastFollowupSuggestion,
+    // Same reference-stability contract: the reducer replaces the whole
+    // array when appending, never mutates it in-place.
+    unrecognizedDiagnostics: state.unrecognizedDiagnostics
   };
   const onTruncation = opts.onTruncation ?? truncationCallbacks.get(state);
   if (onTruncation) truncationCallbacks.set(next, onTruncation);
   return next;
 }
 __name(cloneTranscriptState, "cloneTranscriptState");
+function sharesSourceRecordId(a, b) {
+  const aIds = a.sourceRecordIds;
+  const bIds = b.sourceRecordIds;
+  if (!aIds?.length || !bIds?.length) return false;
+  const set = new Set(aIds);
+  return bIds.some((recordId) => set.has(recordId));
+}
+__name(sharesSourceRecordId, "sharesSourceRecordId");
 function trimTranscriptState(state) {
-  if (state.blocks.length <= state.maxBlocks) return state;
-  truncationCallbacks.get(state)?.({ kind: "blocks" });
-  const blocks = state.blocks.slice(-state.maxBlocks);
+  const overByteBudget = state.retainedBytes > state.maxRetainedBytes;
+  if (state.blocks.length <= state.maxBlocks && !overByteBudget) return state;
+  const effectiveMaxBlocks = Math.max(
+    1,
+    Math.floor(Number.isFinite(state.maxBlocks) ? state.maxBlocks : 1)
+  );
+  let removeCount = Math.max(0, state.blocks.length - effectiveMaxBlocks);
+  let bytes = state.retainedBytes;
+  for (let i = 0; i < removeCount; i += 1) {
+    bytes -= estimateBlockBytes(state.blocks[i]);
+  }
+  while (removeCount < state.blocks.length - 1 && bytes > state.maxRetainedBytes) {
+    bytes -= estimateBlockBytes(state.blocks[removeCount]);
+    removeCount += 1;
+  }
+  while (removeCount > 0 && removeCount < state.blocks.length - 1 && sharesSourceRecordId(
+    state.blocks[removeCount - 1],
+    state.blocks[removeCount]
+  )) {
+    bytes -= estimateBlockBytes(state.blocks[removeCount]);
+    removeCount += 1;
+  }
+  while (removeCount > 0 && sharesSourceRecordId(
+    state.blocks[removeCount - 1],
+    state.blocks[removeCount]
+  )) {
+    removeCount -= 1;
+    bytes += estimateBlockBytes(state.blocks[removeCount]);
+  }
+  if (removeCount === 0) return state;
+  state.retainedBytes = Math.max(0, bytes);
+  const blocks = state.blocks.slice(removeCount);
   const keptIds = new Set(blocks.map((block) => block.id));
   state.blocks = blocks;
   state.blockIndexById = rebuildDaemonTranscriptBlockIndex(blocks);
   ownedBlocks.set(state, state.blocks);
+  ownedBlockIndexes.set(state, state.blockIndexById);
   for (const [toolCallId, blockId] of Object.entries(state.toolBlockByCallId)) {
     if (!keptIds.has(blockId)) {
       state.toolBlockByCallId[toolCallId] = TRIMMED_TOOL_BLOCK_ID;
@@ -9886,6 +10436,18 @@ function trimTranscriptState(state) {
       delete state.activeThoughtBlockByParent[parentId];
     }
   }
+  const oldestRetainedBlock = state.blocks.find(
+    (block) => (block.sourceRecordIds?.length ?? 0) > 0
+  );
+  truncationCallbacks.get(state)?.({
+    kind: "blocks",
+    oldestRetainedRecordId: oldestRetainedBlock?.sourceRecordIds?.[0],
+    evictedOldest: true,
+    blockCount: state.blocks.length,
+    retainedBytes: state.retainedBytes,
+    maxBlocks: state.maxBlocks,
+    maxRetainedBytes: state.maxRetainedBytes
+  });
   return state;
 }
 __name(trimTranscriptState, "trimTranscriptState");
@@ -9894,13 +10456,19 @@ function shouldRecreateTrimmedToolBlock(event) {
 }
 __name(shouldRecreateTrimmedToolBlock, "shouldRecreateTrimmedToolBlock");
 var ownedBlocks = /* @__PURE__ */ new WeakMap();
+var ownedBlockIndexes = /* @__PURE__ */ new WeakMap();
 function takeBlocksOwnership(state) {
   if (ownedBlocks.get(state) === state.blocks) return;
   state.blocks = [...state.blocks];
-  state.blockIndexById = createIndex(state.blockIndexById);
   ownedBlocks.set(state, state.blocks);
 }
 __name(takeBlocksOwnership, "takeBlocksOwnership");
+function takeBlockIndexOwnership(state) {
+  if (ownedBlockIndexes.get(state) === state.blockIndexById) return;
+  state.blockIndexById = createIndex(state.blockIndexById);
+  ownedBlockIndexes.set(state, state.blockIndexById);
+}
+__name(takeBlockIndexOwnership, "takeBlockIndexOwnership");
 function rewindTranscriptToUserTurn(state, targetTurnIndex) {
   let userTurnIndex = 0;
   let lastUserIndex = -1;
@@ -9920,9 +10488,31 @@ function rewindTranscriptToUserTurn(state, targetTurnIndex) {
 __name(rewindTranscriptToUserTurn, "rewindTranscriptToUserTurn");
 function truncateTranscriptBeforeBlock(state, blockIndex) {
   takeBlocksOwnership(state);
+  const originalLength = state.blocks.length;
+  let droppedBytes = 0;
+  for (let index = blockIndex; index < state.blocks.length; index += 1) {
+    const block = state.blocks[index];
+    if (block) droppedBytes += estimateBlockBytes(block);
+  }
   state.blocks = state.blocks.slice(0, blockIndex);
+  state.retainedBytes = Math.max(0, state.retainedBytes - droppedBytes);
   ownedBlocks.set(state, state.blocks);
   rebuildTranscriptIndexes(state);
+  ownedBlockIndexes.set(state, state.blockIndexById);
+  if (state.blocks.length < originalLength) {
+    const oldestRetainedBlock = state.blocks.find(
+      (block) => (block.sourceRecordIds?.length ?? 0) > 0
+    );
+    truncationCallbacks.get(state)?.({
+      kind: "blocks",
+      oldestRetainedRecordId: oldestRetainedBlock?.sourceRecordIds?.[0],
+      evictedOldest: false,
+      blockCount: state.blocks.length,
+      retainedBytes: state.retainedBytes,
+      maxBlocks: state.maxBlocks,
+      maxRetainedBytes: state.maxRetainedBytes
+    });
+  }
 }
 __name(truncateTranscriptBeforeBlock, "truncateTranscriptBeforeBlock");
 function rebuildTranscriptIndexes(state) {
@@ -9956,8 +10546,10 @@ function rebuildTranscriptIndexes(state) {
 __name(rebuildTranscriptIndexes, "rebuildTranscriptIndexes");
 function appendBlock(state, block) {
   takeBlocksOwnership(state);
+  takeBlockIndexOwnership(state);
   state.blockIndexById[block.id] = state.blocks.length;
   state.blocks.push(block);
+  state.retainedBytes += estimateBlockBytes(block);
 }
 __name(appendBlock, "appendBlock");
 function getWritableBlockById(state, blockId) {
@@ -10012,21 +10604,35 @@ function clearActiveText(state, parentToolCallId) {
 __name(clearActiveText, "clearActiveText");
 function appendBoundedText(state, block, text) {
   const existing = "text" in block ? block.text : "";
+  let next;
   if (existing.length >= MAX_TEXT_BLOCK_LENGTH) {
     if (text) reportTextTruncation(state, block.id, block.sourceRecordIds);
-    return existing;
+    next = existing;
+  } else {
+    next = truncateText(
+      state,
+      block.id,
+      block.sourceRecordIds,
+      existing + text
+    );
   }
-  return truncateText(state, block.id, block.sourceRecordIds, existing + text);
+  state.retainedBytes += (next.length - existing.length) * 2;
+  return next;
 }
 __name(appendBoundedText, "appendBoundedText");
-function truncateText(state, blockId, sourceRecordIds, text) {
+function truncateTextAtLimit(text) {
   if (text.length <= MAX_TEXT_BLOCK_LENGTH) return text;
-  reportTextTruncation(state, blockId, sourceRecordIds);
   const keepLength = Math.max(
     0,
     MAX_TEXT_BLOCK_LENGTH - TEXT_TRUNCATED_SUFFIX.length
   );
-  return `${text.slice(0, keepLength)}${TEXT_TRUNCATED_SUFFIX}`;
+  return `${detachString(text.slice(0, keepLength))}${TEXT_TRUNCATED_SUFFIX}`;
+}
+__name(truncateTextAtLimit, "truncateTextAtLimit");
+function truncateText(state, blockId, sourceRecordIds, text) {
+  if (text.length <= MAX_TEXT_BLOCK_LENGTH) return text;
+  reportTextTruncation(state, blockId, sourceRecordIds);
+  return truncateTextAtLimit(text);
 }
 __name(truncateText, "truncateText");
 function reportTextTruncation(state, blockId, sourceRecordIds) {
@@ -10037,6 +10643,35 @@ function reportTextTruncation(state, blockId, sourceRecordIds) {
   });
 }
 __name(reportTextTruncation, "reportTextTruncation");
+function estimateRetainedBytes(value, depth = 0) {
+  if (depth > MAX_CLONE_DEPTH) return 0;
+  if (typeof value === "string") return value.length * 2;
+  if (typeof value === "number" || typeof value === "boolean") return 16;
+  if (typeof Blob !== "undefined" && value instanceof Blob) return value.size;
+  if (value instanceof ArrayBuffer) return value.byteLength;
+  if (ArrayBuffer.isView(value)) return value.byteLength;
+  if (Array.isArray(value)) {
+    let total = 32;
+    for (const entry of value) {
+      total += estimateRetainedBytes(entry, depth + 1);
+    }
+    return total;
+  }
+  if (isRecord2(value)) {
+    let total = 64;
+    for (const [key, entry] of Object.entries(value)) {
+      total += key.length * 2 + estimateRetainedBytes(entry, depth + 1);
+    }
+    return total;
+  }
+  return 0;
+}
+__name(estimateRetainedBytes, "estimateRetainedBytes");
+function estimateDaemonTranscriptBlockBytes(block) {
+  return estimateRetainedBytes(block);
+}
+__name(estimateDaemonTranscriptBlockBytes, "estimateDaemonTranscriptBlockBytes");
+var estimateBlockBytes = estimateDaemonTranscriptBlockBytes;
 function createIndex(source) {
   return Object.assign(/* @__PURE__ */ Object.create(null), source);
 }
@@ -10120,6 +10755,10 @@ function selectLastFollowupSuggestion(state) {
   return state.lastFollowupSuggestion;
 }
 __name(selectLastFollowupSuggestion, "selectLastFollowupSuggestion");
+function selectUnrecognizedDiagnostics(state) {
+  return state.unrecognizedDiagnostics;
+}
+__name(selectUnrecognizedDiagnostics, "selectUnrecognizedDiagnostics");
 function selectToolProgress(state, toolCallId) {
   return state.toolProgress[toolCallId];
 }
@@ -10206,7 +10845,9 @@ __name(getTimestampFormatter, "getTimestampFormatter");
 // packages/sdk-typescript/src/daemon/ui/store.ts
 init_esbuild_shims();
 function createDaemonTranscriptStore(seed = {}) {
-  let state = createState(seed);
+  const { onTruncation, ...stateSeed } = seed;
+  const reducerOptions = onTruncation ? { onTruncation } : {};
+  let state = createState(stateSeed);
   const listeners = /* @__PURE__ */ new Set();
   let notifyScheduled = false;
   const notify = /* @__PURE__ */ __name(() => {
@@ -10239,20 +10880,22 @@ function createDaemonTranscriptStore(seed = {}) {
     dispatch(event) {
       const events = Array.isArray(event) ? event : [event];
       if (events.length === 0) return;
-      state = reduceDaemonTranscriptEvents(state, events);
+      state = reduceDaemonTranscriptEvents(state, events, reducerOptions);
       scheduleNotify();
     },
     appendLocalUserMessage(text, images, meta, files) {
       state = appendLocalUserTranscriptMessage(state, text, {
         images,
         meta,
-        files
+        files,
+        ...reducerOptions
       });
       scheduleNotify();
     },
     reset(nextSeed = {}) {
       state = createState({
         maxBlocks: nextSeed.maxBlocks ?? state.maxBlocks,
+        maxRetainedBytes: nextSeed.maxRetainedBytes ?? state.maxRetainedBytes,
         retainSubagentBlocks: nextSeed.retainSubagentBlocks ?? state.retainSubagentBlocks,
         ...nextSeed
       });
@@ -10313,10 +10956,17 @@ function createState(seed) {
   return {
     ...createDaemonTranscriptState({
       maxBlocks: seed.maxBlocks,
+      maxRetainedBytes: seed.maxRetainedBytes,
       now: seed.now
     }),
     ...seed,
     blocks,
+    // Seeded blocks (e.g. a replay snapshot handed to `reset`) must count
+    // toward the retention byte budget from the start.
+    retainedBytes: seed.retainedBytes ?? blocks.reduce(
+      (total, block) => total + estimateDaemonTranscriptBlockBytes(block),
+      0
+    ),
     blockIndexById: rebuildDaemonTranscriptBlockIndex(blocks),
     toolBlockByCallId: createNullIndex(seed.toolBlockByCallId),
     trimmedToolNotificationByCallId: createNullIndex(
@@ -10563,6 +11213,8 @@ function daemonUiEventToTerminalText(event) {
       return "";
     case "user.image.delta":
       return `[image: ${sanitizeTerminalText(event.mimeType)}]`;
+    case "user.file.delta":
+      return `[file: ${sanitizeTerminalText(event.name)}]`;
     default:
       return assertNever(event);
   }
@@ -11497,6 +12149,7 @@ export {
   DAEMON_PLAN_TOOL_CALL_ID,
   DAEMON_UI_CONFORMANCE_FIXTURES,
   DAEMON_UI_DEBUG_REASONS,
+  DAEMON_UI_UNRECOGNIZED_DIAGNOSTIC_REASONS,
   DEVICE_FLOW_EXPIRY_GRACE_MS,
   DaemonAuthFlow,
   DaemonCapabilityMissingError,
@@ -11512,6 +12165,7 @@ export {
   PENDING_PROMPT_COMPLETED_EVENT,
   PENDING_PROMPT_STARTED_EVENT,
   SseFramingError,
+  UNRECOGNIZED_DIAGNOSTICS_LIMIT,
   WorkspaceDaemonClient,
   appendLocalUserTranscriptMessage,
   asKnownDaemonEvent,
@@ -11525,6 +12179,7 @@ export {
   daemonBlockToPlainText,
   daemonToolPreviewToMarkdown,
   daemonUiEventToTerminalText,
+  estimateDaemonTranscriptBlockBytes,
   extractContentPart,
   extractServerTimestamp,
   formatBlockTimestamp,
@@ -11540,6 +12195,9 @@ export {
   isStaleBranchPointError,
   isSubagentChildBlock,
   isSubagentSessionNotFound,
+  isTrimmedPermissionBlockId,
+  isTrimmedToolBlockId,
+  isUnrecognizedDiagnosticReason,
   isWorkspaceScopedBudgetEvent,
   matchTurnEvent,
   normalizeDaemonEvent,
@@ -11562,6 +12220,7 @@ export {
   selectToolProgress,
   selectTranscriptBlocks,
   selectTranscriptBlocksOrderedByEventId,
+  selectUnrecognizedDiagnostics,
   stringifyJson as stringifyDaemonUiJson,
   stripOscSequences as stripDaemonOscSequences,
   transcriptBlockToTerminalText