@qwen-code/qwen-code 0.19.8 → 0.19.9-preview.0

package/chunks/{daemon-WPAENEBW.js → daemon-MI5HF26N.js}

@@ -1,8 +1,11 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  CHANNEL_CONTROL_DEFAULT_TIMEOUT_MS
+} from "./chunk-5HBA2Z7V.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";
@@ -339,10 +342,12 @@ var RestSseTransport = class {
   _disposed = false;
   type = "rest";
   supportsReplay = true;
+  restFetch;
   constructor(baseUrl, token, fetchFn) {
     this.baseUrl = baseUrl;
     this.token = token;
     this._fetch = fetchFn;
+    this.restFetch = fetchFn;
   }
   get connected() {
     return !this._disposed;
@@ -477,6 +482,7 @@ var DEFAULT_SESSION_LIST_PAGE_SIZE = 20;
 var DEFAULT_FETCH_TIMEOUT_MS = 3e4;
 var VOICE_TRANSCRIPTION_DEFAULT_TIMEOUT_MS = 65e3;
 var GITHUB_SETUP_DEFAULT_TIMEOUT_MS = 9e4;
+var MAX_TIMER_DELAY_MS = 2147483647;
 var DEFAULT_MAX_PENDING_PROMPTS_PER_SESSION = 5;
 var MCP_RESTART_DEFAULT_TIMEOUT_MS = MCP_RESTART_SERVER_DEADLINE_MS + MCP_RESTART_CLIENT_HEADROOM_MS;
 var CLIENT_ID_HEADER = "X-Qwen-Client-Id";
@@ -567,7 +573,7 @@ var DaemonClient = class {
   constructor(opts) {
     this.baseUrl = stripTrailingSlashes(opts.baseUrl);
     this.token = opts.token ?? readTokenFromEnv();
-    this._fetch = opts.fetch ?? globalThis.fetch.bind(globalThis);
+    this._fetch = opts.fetch ?? opts.transport?.restFetch ?? globalThis.fetch.bind(globalThis);
     const raw = opts.fetchTimeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS;
     this.fetchTimeoutMs = Number.isFinite(raw) && raw > 0 ? raw : 0;
     this.promptLimit = normalizePendingPromptLimit(
@@ -677,15 +683,85 @@ var DaemonClient = class {
           hasBody ? { "Content-Type": "application/json" } : {},
           opts.clientId
         ),
-        ...hasBody ? { body: JSON.stringify(opts.body) } : {}
+        ...hasBody ? { body: JSON.stringify(opts.body) } : {},
+        ...opts.signal ? { signal: opts.signal } : {}
       },
       async (res) => {
         if (!res.ok) throw await this.failOnError(res, label);
         return await res.json();
       },
+      opts.timeoutMs,
+      opts.mode
+    );
+  }
+  /** @internal */
+  async workspaceJsonRequest(workspaceSelector, path, label, opts = {}) {
+    return await this.jsonRequest(
+      `/workspaces/${workspaceSelector}${path}`,
+      label,
+      opts
+    );
+  }
+  /** @internal */
+  async sessionExportRequest(path, label, opts = {}) {
+    const format = opts.format ?? "html";
+    const query = opts.format ? `?format=${urlEncode(opts.format)}` : "";
+    return await this.fetchWithTimeout(
+      `${this.baseUrl}${path}${query}`,
+      { headers: this.headers({}, opts.clientId) },
+      async (res) => {
+        if (!res.ok) {
+          throw await this.failOnError(res, label);
+        }
+        const content = await res.text();
+        const mimeType = res.headers.get("content-type") ?? "";
+        const filename = /filename="([^"]+)"/i.exec(
+          res.headers.get("content-disposition") ?? ""
+        )?.[1] ?? `export.${format}`;
+        return {
+          content,
+          filename,
+          mimeType,
+          format
+        };
+      },
+      void 0,
+      "rest"
+    );
+  }
+  /** @internal */
+  async workspaceNoContentRequest(workspaceSelector, path, label, opts = {}) {
+    return await this.fetchWithTimeout(
+      `${this.baseUrl}/workspaces/${workspaceSelector}${path}`,
+      {
+        ...opts.method ? { method: opts.method } : {},
+        headers: this.headers({}, opts.clientId)
+      },
+      async (res) => {
+        if (res.status === 204) {
+          try {
+            await res.body?.cancel();
+          } catch {
+          }
+          return;
+        }
+        if (res.status === 404 && opts.okNotFoundCode) {
+          const err = await this.failOnError(res, label);
+          const body = err.body;
+          if (body?.code === opts.okNotFoundCode) return;
+          throw err;
+        }
+        throw await this.failOnError(res, label);
+      },
       opts.timeoutMs
     );
   }
+  workspaceById(workspaceId) {
+    return new WorkspaceDaemonClient(this, urlEncode(workspaceId));
+  }
+  workspaceByCwd(workspaceCwd) {
+    return new WorkspaceDaemonClient(this, urlEncode(workspaceCwd));
+  }
   // -- Lifecycle / discovery ---------------------------------------------
   async health() {
     return await this.fetchWithTimeout(
@@ -748,6 +824,13 @@ var DaemonClient = class {
       }
     );
   }
+  async workspaceGit() {
+    return await this.jsonRequest(
+      "/workspace/git",
+      "GET /workspace/git",
+      { mode: "rest" }
+    );
+  }
   async workspaceMcpTools(serverName) {
     return await this.fetchWithTimeout(
       `${this.baseUrl}/workspace/mcp/${urlEncode(serverName)}/tools`,
@@ -787,6 +870,33 @@ var DaemonClient = class {
       }
     );
   }
+  async workspaceAcpPreheat(timeoutMs) {
+    const serverBudgetMs = timeoutMs ?? 5e3;
+    const suffix = timeoutMs !== void 0 ? `?timeoutMs=${encodeURIComponent(timeoutMs)}` : "";
+    return await this.fetchWithTimeout(
+      `${this.baseUrl}/workspace/acp/preheat${suffix}`,
+      { method: "POST", headers: this.headers() },
+      async (res) => {
+        if (!res.ok) {
+          throw await this.failOnError(res, "POST /workspace/acp/preheat");
+        }
+        return await res.json();
+      },
+      serverBudgetMs + 2e3
+    );
+  }
+  async workspaceAcpStatus() {
+    return await this.fetchWithTimeout(
+      `${this.baseUrl}/workspace/acp/status`,
+      { headers: this.headers() },
+      async (res) => {
+        if (!res.ok) {
+          throw await this.failOnError(res, "GET /workspace/acp/status");
+        }
+        return await res.json();
+      }
+    );
+  }
   async workspaceProviders() {
     return await this.fetchWithTimeout(
       `${this.baseUrl}/workspace/providers`,
@@ -823,64 +933,230 @@ var DaemonClient = class {
   async workspaceExtensions() {
     return await this.jsonRequest(
       "/workspace/extensions",
-      "GET /workspace/extensions"
+      "GET /workspace/extensions",
+      { mode: "rest" }
     );
   }
   async installExtension(params, clientId) {
     return await this.jsonRequest(
       "/workspace/extensions/install",
       "POST /workspace/extensions/install",
-      { method: "POST", body: params, clientId }
+      { method: "POST", body: params, clientId, mode: "rest" }
     );
   }
   async extensionOperationStatus(operationId) {
     return await this.jsonRequest(
       `/workspace/extensions/operations/${urlEncode(operationId)}`,
-      "GET /workspace/extensions/operations/:operationId"
+      "GET /workspace/extensions/operations/:operationId",
+      { mode: "rest" }
+    );
+  }
+  async activeExtensionOperations() {
+    return await this.jsonRequest(
+      "/workspace/extensions/operations",
+      "GET /workspace/extensions/operations",
+      { mode: "rest" }
+    );
+  }
+  async respondToExtensionInteraction(operationId, interactionId, response, clientId) {
+    return await this.jsonRequest(
+      `/workspace/extensions/operations/${urlEncode(operationId)}/interactions/${urlEncode(interactionId)}`,
+      "POST /workspace/extensions/operations/:operationId/interactions/:interactionId",
+      { method: "POST", body: response, clientId, mode: "rest" }
     );
   }
   async checkExtensionUpdates(clientId) {
     return await this.jsonRequest(
       "/workspace/extensions/check-updates",
       "POST /workspace/extensions/check-updates",
-      { method: "POST", body: {}, clientId }
+      { method: "POST", body: {}, clientId, mode: "rest" }
     );
   }
   async refreshExtensions(clientId) {
     return await this.jsonRequest(
       "/workspace/extensions/refresh",
       "POST /workspace/extensions/refresh",
-      { method: "POST", body: {}, clientId }
+      { method: "POST", body: {}, clientId, mode: "rest" }
     );
   }
   async enableExtension(name, params, clientId) {
     return await this.jsonRequest(
       `/workspace/extensions/${urlEncode(name)}/enable`,
       "POST /workspace/extensions/:name/enable",
-      { method: "POST", body: params, clientId }
+      { method: "POST", body: params, clientId, mode: "rest" }
     );
   }
   async disableExtension(name, params, clientId) {
     return await this.jsonRequest(
       `/workspace/extensions/${urlEncode(name)}/disable`,
       "POST /workspace/extensions/:name/disable",
-      { method: "POST", body: params, clientId }
+      { method: "POST", body: params, clientId, mode: "rest" }
     );
   }
   async updateExtension(name, clientId) {
     return await this.jsonRequest(
       `/workspace/extensions/${urlEncode(name)}/update`,
       "POST /workspace/extensions/:name/update",
-      { method: "POST", body: {}, clientId }
+      { method: "POST", body: {}, clientId, mode: "rest" }
     );
   }
   async uninstallExtension(name, clientId) {
     return await this.jsonRequest(
       `/workspace/extensions/${urlEncode(name)}`,
       "DELETE /workspace/extensions/:name",
-      { method: "DELETE", clientId }
+      { method: "DELETE", clientId, mode: "rest" }
+    );
+  }
+  async extensionCatalog() {
+    return await this.jsonRequest(
+      "/extensions",
+      "GET /extensions",
+      { mode: "rest" }
     );
   }
+  async installUserExtension(params, clientId) {
+    return await this.jsonRequest(
+      "/extensions/install",
+      "POST /extensions/install",
+      { method: "POST", body: params, clientId, mode: "rest" }
+    );
+  }
+  async checkUserExtensionUpdates(clientId) {
+    return await this.jsonRequest(
+      "/extensions/check-updates",
+      "POST /extensions/check-updates",
+      { method: "POST", body: {}, clientId, mode: "rest" }
+    );
+  }
+  async updateUserExtension(extensionId, clientId) {
+    return await this.jsonRequest(
+      `/extensions/${urlEncode(extensionId)}/update`,
+      "POST /extensions/:extensionId/update",
+      { method: "POST", body: {}, clientId, mode: "rest" }
+    );
+  }
+  async uninstallUserExtension(extensionId, clientId) {
+    return await this.fetchWithTimeout(
+      `${this.baseUrl}/extensions/${urlEncode(extensionId)}`,
+      {
+        method: "DELETE",
+        headers: this.headers({}, clientId)
+      },
+      async (res) => {
+        if (res.status === 204) {
+          await res.body?.cancel().catch(() => void 0);
+          return void 0;
+        }
+        if (!res.ok) {
+          throw await this.failOnError(res, "DELETE /extensions/:extensionId");
+        }
+        return await res.json();
+      },
+      void 0,
+      "rest"
+    );
+  }
+  async setExtensionDefaultActivation(extensionId, state, clientId) {
+    return await this.jsonRequest(
+      `/extensions/${urlEncode(extensionId)}/activation`,
+      "PUT /extensions/:extensionId/activation",
+      { method: "PUT", body: { state }, clientId, mode: "rest" }
+    );
+  }
+  async extensionOperation(operationId, signal) {
+    return await this.jsonRequest(
+      `/extensions/operations/${urlEncode(operationId)}`,
+      "GET /extensions/operations/:operationId",
+      signal ? { signal, mode: "rest" } : { mode: "rest" }
+    );
+  }
+  async waitForExtensionOperation(handle, options = {}) {
+    const pollIntervalMs = options.pollIntervalMs ?? 1e3;
+    const timeoutMs = options.timeoutMs ?? 10 * 6e4;
+    const hasDeadline = timeoutMs !== Number.POSITIVE_INFINITY;
+    const deadline = Date.now() + timeoutMs;
+    const timeoutError = /* @__PURE__ */ __name(() => new Error(
+      `Timed out waiting for extension operation ${handle.operationId}. The server operation was not cancelled.`
+    ), "timeoutError");
+    for (; ; ) {
+      options.signal?.throwIfAborted();
+      const pollBudgetMs = deadline - Date.now();
+      if (pollBudgetMs <= 0 || Number.isNaN(pollBudgetMs)) {
+        throw timeoutError();
+      }
+      let operation;
+      if (!hasDeadline) {
+        operation = await this.extensionOperation(
+          handle.operationId,
+          options.signal
+        );
+      } else {
+        const deadlineController = new AbortController();
+        const pollSignal = options.signal ? composeAbortSignals2([options.signal, deadlineController.signal]) : deadlineController.signal;
+        let deadlineTimer;
+        const deadlinePromise = new Promise((_, reject) => {
+          const expire = /* @__PURE__ */ __name(() => {
+            const error = timeoutError();
+            reject(error);
+            deadlineController.abort(error);
+          }, "expire");
+          const schedule = /* @__PURE__ */ __name(() => {
+            const remainingMs2 = deadline - Date.now();
+            if (remainingMs2 <= 0) {
+              expire();
+              return;
+            }
+            deadlineTimer = setTimeout(
+              () => {
+                if (Date.now() >= deadline) {
+                  expire();
+                } else {
+                  schedule();
+                }
+              },
+              Math.min(remainingMs2, MAX_TIMER_DELAY_MS)
+            );
+          }, "schedule");
+          schedule();
+        });
+        try {
+          operation = await Promise.race([
+            this.extensionOperation(handle.operationId, pollSignal),
+            deadlinePromise
+          ]);
+        } finally {
+          if (deadlineTimer !== void 0) clearTimeout(deadlineTimer);
+          deadlineController.abort();
+        }
+      }
+      if (operation.status !== "queued" && operation.status !== "running") {
+        return operation;
+      }
+      const remainingMs = deadline - Date.now();
+      if (remainingMs <= 0) {
+        throw timeoutError();
+      }
+      await new Promise((resolve, reject) => {
+        const finish = /* @__PURE__ */ __name(() => {
+          options.signal?.removeEventListener("abort", onAbort);
+          resolve();
+        }, "finish");
+        const timer = setTimeout(
+          finish,
+          Math.min(pollIntervalMs, remainingMs, MAX_TIMER_DELAY_MS)
+        );
+        const onAbort = /* @__PURE__ */ __name(() => {
+          clearTimeout(timer);
+          options.signal?.removeEventListener("abort", onAbort);
+          reject(
+            options.signal?.reason ?? new DOMException("Aborted", "AbortError")
+          );
+        }, "onAbort");
+        options.signal?.addEventListener("abort", onAbort, { once: true });
+        if (options.signal?.aborted) onAbort();
+      });
+    }
+  }
   // -- Workspace files (workspace files) -------------------------------
   async readWorkspaceFile(filePath, opts = {}, clientId) {
     const url = new URL(`${this.baseUrl}/file`);
@@ -1279,7 +1555,8 @@ var DaemonClient = class {
           // invalid_session_scope` surface the bug. Same shape the
           // bridge's own validation uses (`httpAcpBridge.ts:
           // spawnOrAttach`); SDK should be a transparent layer here.
-          ...req.sessionScope !== void 0 ? { sessionScope: req.sessionScope } : {}
+          ...req.sessionScope !== void 0 ? { sessionScope: req.sessionScope } : {},
+          ...req.approvalMode !== void 0 ? { approvalMode: req.approvalMode } : {}
         })
       },
       async (res) => {
@@ -1289,8 +1566,8 @@ var DaemonClient = class {
     );
   }
   /**
-   * Enumerate live sessions in the given workspace. Used by session-picker
-   * UIs. Returns an empty list (not 404) when the workspace has no sessions.
+   * Enumerate the session catalog for a workspace. Used by session-picker UIs.
+   * Returns an empty list (not 404) when the workspace has no sessions.
    */
   async listWorkspaceSessions(workspaceCwd, options) {
     const page = await this.listWorkspaceSessionsPage(workspaceCwd, options);
@@ -1320,6 +1597,9 @@ var DaemonClient = class {
     if (options?.group !== void 0) {
       query.set("group", options.group);
     }
+    if (options?.parentSessionId !== void 0) {
+      query.set("parentSessionId", options.parentSessionId);
+    }
     return await this.jsonRequest(
       `/workspace/${urlEncode(workspaceCwd)}/sessions?${query.toString()}`,
       "GET /workspace/sessions"
@@ -1365,29 +1645,24 @@ var DaemonClient = class {
     return this.restoreSession("load", sessionId, req, clientId);
   }
   async exportSession(sessionId, opts = {}) {
-    const format = opts.format ?? "html";
-    const query = opts.format ? `?format=${urlEncode(opts.format)}` : "";
-    return await this.fetchWithTimeout(
-      `${this.baseUrl}/session/${urlEncode(sessionId)}/export${query}`,
-      { headers: this.headers({}, opts.clientId) },
-      async (res) => {
-        if (!res.ok) {
-          throw await this.failOnError(res, "GET /session/:id/export");
-        }
-        const content = await res.text();
-        const mimeType = res.headers.get("content-type") ?? "";
-        const filename = /filename="([^"]+)"/i.exec(
-          res.headers.get("content-disposition") ?? ""
-        )?.[1] ?? `export.${format}`;
-        return {
-          content,
-          filename,
-          mimeType,
-          format
-        };
-      },
-      void 0,
-      "rest"
+    return await this.sessionExportRequest(
+      `/session/${urlEncode(sessionId)}/export`,
+      "GET /session/:id/export",
+      opts
+    );
+  }
+  async getSessionTranscriptPage(sessionId, opts = {}) {
+    const params = new URLSearchParams();
+    if (opts.cursor !== void 0) params.set("cursor", opts.cursor);
+    if (opts.limit !== void 0) params.set("limit", String(opts.limit));
+    const query = params.toString();
+    return await this.jsonRequest(
+      `/session/${urlEncode(sessionId)}/transcript${query ? `?${query}` : ""}`,
+      "GET /session/:id/transcript",
+      {
+        clientId: opts.clientId,
+        mode: "rest"
+      }
     );
   }
   async resumeSession(sessionId, req = {}, clientId) {
@@ -1437,6 +1712,21 @@ var DaemonClient = class {
       }
     );
   }
+  /**
+   * Read the current in-memory runtime status for one live daemon session.
+   */
+  async sessionStatus(sessionId, clientId) {
+    return await this.fetchWithTimeout(
+      `${this.baseUrl}/session/${urlEncode(sessionId)}/status`,
+      { headers: this.headers({}, clientId) },
+      async (res) => {
+        if (!res.ok) {
+          throw await this.failOnError(res, "GET /session/:id/status");
+        }
+        return await res.json();
+      }
+    );
+  }
   async sessionContextUsage(sessionId, opts = {}, clientId) {
     const params = new URLSearchParams();
     if (opts.detail === true) params.set("detail", "true");
@@ -1551,7 +1841,10 @@ var DaemonClient = class {
       {
         method: "POST",
         headers: this.headers({ "Content-Type": "application/json" }, clientId),
-        body: JSON.stringify({ cwd: req.workspaceCwd })
+        body: JSON.stringify({
+          cwd: req.workspaceCwd,
+          ...req.approvalMode !== void 0 ? { approvalMode: req.approvalMode } : {}
+        })
       },
       async (res) => {
         if (!res.ok) {
@@ -1610,7 +1903,9 @@ var DaemonClient = class {
           );
         }
         return await res.json();
-      }
+      },
+      void 0,
+      "rest"
     );
   }
   async rewindSession(sessionId, promptId, opts) {
@@ -1632,7 +1927,9 @@ var DaemonClient = class {
           throw await this.failOnError(res, "POST /session/:id/rewind");
         }
         return await res.json();
-      }
+      },
+      void 0,
+      "rest"
     );
   }
   /**
@@ -1827,6 +2124,35 @@ var DaemonClient = class {
       }
     );
   }
+  /**
+   * Toggle a user-invocable skill in workspace `skills.disabled` settings.
+   * Active ACP sessions refresh their skill validation and command lists before
+   * the response returns; `activation` reports deferred or partial refreshes.
+   *
+   * Pre-flight `caps.features.includes('workspace_skill_toggle')` before calling.
+   */
+  async setWorkspaceSkillEnabled(skillName, enabled, opts) {
+    return await this.fetchWithTimeout(
+      `${this.baseUrl}/workspace/skills/${urlEncode(skillName)}/enable`,
+      {
+        method: "POST",
+        headers: this.headers(
+          { "Content-Type": "application/json" },
+          opts?.clientId
+        ),
+        body: JSON.stringify({ enabled })
+      },
+      async (res) => {
+        if (!res.ok) {
+          throw await this.failOnError(
+            res,
+            "POST /workspace/skills/:name/enable"
+          );
+        }
+        return await res.json();
+      }
+    );
+  }
   async workspaceSettings(opts) {
     return await this.fetchWithTimeout(
       `${this.baseUrl}/workspace/settings`,
@@ -1861,6 +2187,25 @@ var DaemonClient = class {
       }
     );
   }
+  async deleteModel(target, opts) {
+    return await this.fetchWithTimeout(
+      `${this.baseUrl}/workspace/models`,
+      {
+        method: "DELETE",
+        headers: this.headers(
+          { "Content-Type": "application/json" },
+          opts?.clientId
+        ),
+        body: JSON.stringify(target)
+      },
+      async (res) => {
+        if (!res.ok) {
+          throw await this.failOnError(res, "DELETE /workspace/models");
+        }
+        return await res.json();
+      }
+    );
+  }
   async workspaceVoice(clientId) {
     return await this.jsonRequest(
       "/workspace/voice",
@@ -1876,9 +2221,26 @@ var DaemonClient = class {
     );
   }
   async transcribeWorkspaceVoice(audio, opts) {
+    return await this.voiceTranscriptionRequest(
+      "/workspace/voice/transcribe",
+      "POST /workspace/voice/transcribe",
+      audio,
+      opts
+    );
+  }
+  /** @internal */
+  async workspaceVoiceTranscriptionRequest(workspaceSelector, audio, opts) {
+    return await this.voiceTranscriptionRequest(
+      `/workspaces/${workspaceSelector}/voice/transcribe`,
+      "POST /workspaces/:workspace/voice/transcribe",
+      audio,
+      opts
+    );
+  }
+  async voiceTranscriptionRequest(path, label, audio, opts) {
     const query = opts.voiceModel ? `?${new URLSearchParams({ voiceModel: opts.voiceModel }).toString()}` : "";
     return await this.fetchWithTimeout(
-      `${this.baseUrl}/workspace/voice/transcribe${query}`,
+      `${this.baseUrl}${path}${query}`,
       {
         method: "POST",
         headers: this.headers({ "Content-Type": opts.mimeType }, opts.clientId),
@@ -1886,11 +2248,11 @@ var DaemonClient = class {
       },
       async (res) => {
         if (!res.ok) {
-          throw await this.failOnError(res, "POST /workspace/voice/transcribe");
+          throw await this.failOnError(res, label);
         }
         return await res.json();
       },
-      VOICE_TRANSCRIPTION_DEFAULT_TIMEOUT_MS,
+      opts.timeoutMs ?? VOICE_TRANSCRIPTION_DEFAULT_TIMEOUT_MS,
       "rest"
     );
   }
@@ -2047,6 +2409,84 @@ var DaemonClient = class {
       opts?.timeoutMs
     );
   }
+  /**
+   * Reload the daemon-managed channel worker: the daemon stops and relaunches
+   * it so it re-reads settings.json (channels / proxy / per-channel model).
+   * Requires an enabled runtime selection; otherwise the route responds 409.
+   * Pre-flight the dynamic `channel_reload` capability.
+   */
+  async reloadChannelWorker(opts) {
+    return await this.fetchWithTimeout(
+      `${this.baseUrl}/workspace/channel/reload`,
+      {
+        method: "POST",
+        headers: this.headers(
+          { "Content-Type": "application/json" },
+          opts?.clientId
+        ),
+        body: "{}"
+      },
+      async (res) => {
+        if (!res.ok) {
+          throw await this.failOnError(res, "POST /workspace/channel/reload");
+        }
+        return await res.json();
+      },
+      opts?.timeoutMs ?? CHANNEL_CONTROL_DEFAULT_TIMEOUT_MS
+    );
+  }
+  async getChannelWorkerControl(opts) {
+    return await this.fetchWithTimeout(
+      `${this.baseUrl}/workspace/channel`,
+      {
+        method: "GET",
+        headers: this.headers({}, opts?.clientId)
+      },
+      async (res) => {
+        if (!res.ok) {
+          throw await this.failOnError(res, "GET /workspace/channel");
+        }
+        return await res.json();
+      },
+      opts?.timeoutMs
+    );
+  }
+  async setChannelWorkerSelection(selection, opts) {
+    return await this.fetchWithTimeout(
+      `${this.baseUrl}/workspace/channel`,
+      {
+        method: "PUT",
+        headers: this.headers(
+          { "Content-Type": "application/json" },
+          opts?.clientId
+        ),
+        body: JSON.stringify({ selection })
+      },
+      async (res) => {
+        if (!res.ok) {
+          throw await this.failOnError(res, "PUT /workspace/channel");
+        }
+        return await res.json();
+      },
+      opts?.timeoutMs ?? CHANNEL_CONTROL_DEFAULT_TIMEOUT_MS
+    );
+  }
+  async stopChannelWorker(opts) {
+    return await this.fetchWithTimeout(
+      `${this.baseUrl}/workspace/channel`,
+      {
+        method: "DELETE",
+        headers: this.headers({}, opts?.clientId)
+      },
+      async (res) => {
+        if (!res.ok) {
+          throw await this.failOnError(res, "DELETE /workspace/channel");
+        }
+        return await res.json();
+      },
+      opts?.timeoutMs ?? CHANNEL_CONTROL_DEFAULT_TIMEOUT_MS
+    );
+  }
   async manageMcpServer(serverName, action, opts) {
     return await this.fetchWithTimeout(
       `${this.baseUrl}/workspace/mcp/${urlEncode(serverName)}/${urlEncode(action)}`,
@@ -2653,6 +3093,25 @@ var DaemonClient = class {
       }
     );
   }
+  async addWorkspace(cwd, options = {}) {
+    return await this.fetchWithTimeout(
+      `${this.baseUrl}/workspaces`,
+      {
+        method: "POST",
+        headers: this.headers({ "Content-Type": "application/json" }),
+        body: JSON.stringify({
+          cwd,
+          ...options.persist ? { persist: true } : {}
+        })
+      },
+      async (res) => {
+        if (!res.ok) {
+          throw await this.failOnError(res, "POST /workspaces");
+        }
+        return await res.json();
+      }
+    );
+  }
   // -- Lifecycle / disposal ------------------------------------------------
   /**
    * Release transport resources (WS close, etc.). Idempotent.
@@ -2714,6 +3173,453 @@ var DaemonClient = class {
     );
   }
 };
+var WorkspaceDaemonClient = class {
+  constructor(client, workspaceSelector) {
+    this.client = client;
+    this.workspaceSelector = workspaceSelector;
+  }
+  static {
+    __name(this, "WorkspaceDaemonClient");
+  }
+  workspaceMcp() {
+    return this.get("/mcp", "GET /workspaces/:workspace/mcp");
+  }
+  workspaceVoice(clientId) {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      "/voice",
+      "GET /workspaces/:workspace/voice",
+      { clientId, mode: "rest" }
+    );
+  }
+  setWorkspaceVoice(update, clientId) {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      "/voice",
+      "POST /workspaces/:workspace/voice",
+      { method: "POST", body: update, clientId, mode: "rest" }
+    );
+  }
+  transcribeWorkspaceVoice(audio, opts) {
+    return this.client.workspaceVoiceTranscriptionRequest(
+      this.workspaceSelector,
+      audio,
+      opts
+    );
+  }
+  workspaceGit() {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      "/git",
+      "GET /workspaces/:workspace/git",
+      { mode: "rest" }
+    );
+  }
+  workspaceSkills() {
+    return this.get("/skills", "GET /workspaces/:workspace/skills");
+  }
+  workspaceProviders() {
+    return this.get("/providers", "GET /workspaces/:workspace/providers");
+  }
+  workspaceHooks() {
+    return this.get("/hooks", "GET /workspaces/:workspace/hooks");
+  }
+  workspaceEnv() {
+    return this.get("/env", "GET /workspaces/:workspace/env");
+  }
+  workspacePreflight() {
+    return this.get("/preflight", "GET /workspaces/:workspace/preflight");
+  }
+  workspaceTools() {
+    return this.get("/tools", "GET /workspaces/:workspace/tools");
+  }
+  workspaceMemory() {
+    return this.get("/memory", "GET /workspaces/:workspace/memory");
+  }
+  remove(options) {
+    const body = options?.force === void 0 ? void 0 : {
+      force: options.force
+    };
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      "",
+      "DELETE /workspaces/:workspace",
+      {
+        method: "DELETE",
+        ...body ? { body } : {},
+        ...options?.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : {},
+        mode: "rest"
+      }
+    );
+  }
+  writeWorkspaceMemory(req, clientId) {
+    return this.post(
+      "/memory",
+      "POST /workspaces/:workspace/memory",
+      { ...req, scope: "workspace" },
+      clientId
+    );
+  }
+  listWorkspaceAgents() {
+    return this.get("/agents", "GET /workspaces/:workspace/agents");
+  }
+  createWorkspaceAgent(req, clientId) {
+    return this.post(
+      "/agents",
+      "POST /workspaces/:workspace/agents",
+      { ...req, scope: req.scope ?? "workspace" },
+      clientId
+    );
+  }
+  getWorkspaceAgent(agentType) {
+    return this.get(
+      `/agents/${urlEncode(agentType)}`,
+      "GET /workspaces/:workspace/agents/:agentType"
+    );
+  }
+  updateWorkspaceAgent(agentType, req, opts = {}) {
+    const query = opts.scope ? `?scope=${urlEncode(opts.scope)}` : "";
+    return this.post(
+      `/agents/${urlEncode(agentType)}${query}`,
+      "POST /workspaces/:workspace/agents/:agentType",
+      req,
+      opts.clientId
+    );
+  }
+  async deleteWorkspaceAgent(agentType, opts = {}) {
+    const query = opts.scope ? `?scope=${urlEncode(opts.scope)}` : "";
+    return await this.client.workspaceNoContentRequest(
+      this.workspaceSelector,
+      `/agents/${urlEncode(agentType)}${query}`,
+      "DELETE /workspaces/:workspace/agents/:agentType",
+      {
+        method: "DELETE",
+        clientId: opts.clientId,
+        okNotFoundCode: "agent_not_found"
+      }
+    );
+  }
+  listWorkspaceSessionsPage(options) {
+    const requestedPageSize = options?.pageSize ?? DEFAULT_SESSION_LIST_PAGE_SIZE;
+    const pageSize = Math.max(
+      1,
+      Math.min(
+        1e3,
+        Math.round(
+          Number.isFinite(requestedPageSize) ? requestedPageSize : DEFAULT_SESSION_LIST_PAGE_SIZE
+        )
+      )
+    );
+    const query = new URLSearchParams({ size: String(pageSize) });
+    if (options?.cursor !== void 0) query.set("cursor", options.cursor);
+    if (options?.archiveState !== void 0) {
+      query.set("archiveState", options.archiveState);
+    }
+    if (options?.view !== void 0) query.set("view", options.view);
+    if (options?.group !== void 0) query.set("group", options.group);
+    if (options?.parentSessionId !== void 0) {
+      query.set("parentSessionId", options.parentSessionId);
+    }
+    return this.get(
+      `/sessions?${query.toString()}`,
+      "GET /workspaces/:workspace/sessions"
+    );
+  }
+  async listWorkspaceSessions(options) {
+    const page = await this.listWorkspaceSessionsPage(options);
+    return page.sessions;
+  }
+  /**
+   * Read one page from an active persisted session transcript in this
+   * workspace.
+   * The daemon performs replay locally without attaching to the session or
+   * starting ACP. This method always uses native REST transport.
+   */
+  getSessionTranscriptPage(sessionId, opts = {}) {
+    const query = new URLSearchParams();
+    if (opts.cursor !== void 0) query.set("cursor", opts.cursor);
+    if (opts.limit !== void 0) query.set("limit", String(opts.limit));
+    const suffix = query.size > 0 ? `?${query.toString()}` : "";
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      `/session/${urlEncode(sessionId)}/transcript${suffix}`,
+      "GET /workspaces/:workspace/session/:id/transcript",
+      { clientId: opts.clientId, mode: "rest" }
+    );
+  }
+  /** Export an active persisted session from this registered workspace. */
+  exportSession(sessionId, opts = {}) {
+    return this.client.sessionExportRequest(
+      `/workspaces/${this.workspaceSelector}/session/${urlEncode(sessionId)}/export`,
+      "GET /workspaces/:workspace/session/:id/export",
+      opts
+    );
+  }
+  listSessionGroups() {
+    return this.get(
+      "/session-groups",
+      "GET /workspaces/:workspace/session-groups"
+    );
+  }
+  async createSessionGroup(input) {
+    const body = await this.post(
+      "/session-groups",
+      "POST /workspaces/:workspace/session-groups",
+      input
+    );
+    return body.group;
+  }
+  async updateSessionGroup(groupId, update) {
+    const body = await this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      `/session-groups/${urlEncode(groupId)}`,
+      "PATCH /workspaces/:workspace/session-groups/:groupId",
+      { method: "PATCH", body: update }
+    );
+    return body.group;
+  }
+  deleteSessionGroup(groupId) {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      `/session-groups/${urlEncode(groupId)}`,
+      "DELETE /workspaces/:workspace/session-groups/:groupId",
+      { method: "DELETE" }
+    );
+  }
+  updateSessionOrganization(sessionId, update, clientId) {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      `/session/${urlEncode(sessionId)}/organization`,
+      "PATCH /workspaces/:workspace/session/:id/organization",
+      { method: "PATCH", body: update, clientId }
+    );
+  }
+  deleteSessionsData(sessionIds, clientId) {
+    return this.post(
+      "/sessions/delete",
+      "POST /workspaces/:workspace/sessions/delete",
+      { sessionIds },
+      clientId
+    );
+  }
+  archiveSessionsData(sessionIds, clientId) {
+    return this.post(
+      "/sessions/archive",
+      "POST /workspaces/:workspace/sessions/archive",
+      { sessionIds },
+      clientId
+    );
+  }
+  unarchiveSessionsData(sessionIds, clientId) {
+    return this.post(
+      "/sessions/unarchive",
+      "POST /workspaces/:workspace/sessions/unarchive",
+      { sessionIds },
+      clientId
+    );
+  }
+  readWorkspaceFile(filePath, opts = {}, clientId) {
+    const query = new URLSearchParams({ path: filePath });
+    if (opts.maxBytes !== void 0)
+      query.set("maxBytes", String(opts.maxBytes));
+    if (opts.line !== void 0) query.set("line", String(opts.line));
+    if (opts.limit !== void 0) query.set("limit", String(opts.limit));
+    return this.get(
+      `/file?${query.toString()}`,
+      "GET /workspaces/:workspace/file",
+      clientId
+    );
+  }
+  readWorkspaceFileBytes(filePath, opts = {}, clientId) {
+    const query = new URLSearchParams({ path: filePath });
+    if (opts.offset !== void 0) query.set("offset", String(opts.offset));
+    if (opts.maxBytes !== void 0)
+      query.set("maxBytes", String(opts.maxBytes));
+    return this.get(
+      `/file/bytes?${query.toString()}`,
+      "GET /workspaces/:workspace/file/bytes",
+      clientId
+    );
+  }
+  fileStat(filePath) {
+    const query = new URLSearchParams({ path: filePath });
+    return this.get(
+      `/stat?${query.toString()}`,
+      "GET /workspaces/:workspace/stat"
+    );
+  }
+  dirList(dirPath) {
+    const query = new URLSearchParams({ path: dirPath });
+    return this.get(
+      `/list?${query.toString()}`,
+      "GET /workspaces/:workspace/list"
+    );
+  }
+  glob(pattern, opts = {}) {
+    const query = new URLSearchParams({ pattern });
+    if (opts.maxResults !== void 0) {
+      query.set("maxResults", String(opts.maxResults));
+    }
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      `/glob?${query.toString()}`,
+      "GET /workspaces/:workspace/glob",
+      { signal: opts.signal }
+    );
+  }
+  writeWorkspaceFile(req, clientId) {
+    return this.post(
+      "/file/write",
+      "POST /workspaces/:workspace/file/write",
+      req,
+      clientId
+    );
+  }
+  editWorkspaceFile(req, clientId) {
+    return this.post(
+      "/file/edit",
+      "POST /workspaces/:workspace/file/edit",
+      req,
+      clientId
+    );
+  }
+  workspaceSettings(opts) {
+    return this.get(
+      "/settings",
+      "GET /workspaces/:workspace/settings",
+      opts?.clientId
+    );
+  }
+  setWorkspaceSetting(scope, key, value, opts) {
+    return this.post(
+      "/settings",
+      "POST /workspaces/:workspace/settings",
+      { scope, key, value },
+      opts?.clientId
+    );
+  }
+  workspaceTrust(opts) {
+    return this.get(
+      "/trust",
+      "GET /workspaces/:workspace/trust",
+      opts?.clientId
+    );
+  }
+  requestWorkspaceTrustChange(request, clientId) {
+    return this.post(
+      "/trust/request",
+      "POST /workspaces/:workspace/trust/request",
+      request,
+      clientId
+    );
+  }
+  workspacePermissions(opts) {
+    return this.get(
+      "/permissions",
+      "GET /workspaces/:workspace/permissions",
+      opts?.clientId
+    );
+  }
+  setWorkspacePermissionRules(ruleType, rules, opts) {
+    return this.post(
+      "/permissions",
+      "POST /workspaces/:workspace/permissions",
+      { scope: "workspace", ruleType, rules: [...rules] },
+      opts?.clientId
+    );
+  }
+  setWorkspaceToolEnabled(toolName, enabled, opts) {
+    return this.post(
+      `/tools/${urlEncode(toolName)}/enable`,
+      "POST /workspaces/:workspace/tools/:name/enable",
+      { enabled },
+      opts?.clientId
+    );
+  }
+  setWorkspaceSkillEnabled(skillName, enabled, opts) {
+    return this.post(
+      `/skills/${urlEncode(skillName)}/enable`,
+      "POST /workspaces/:workspace/skills/:name/enable",
+      { enabled },
+      opts?.clientId
+    );
+  }
+  restartMcpServer(serverName, opts) {
+    const query = opts?.entryIndex === void 0 ? "" : `?entryIndex=${urlEncode(String(opts.entryIndex))}`;
+    return this.post(
+      `/mcp/${urlEncode(serverName)}/restart${query}`,
+      "POST /workspaces/:workspace/mcp/:server/restart",
+      {},
+      opts?.clientId,
+      opts?.timeoutMs ?? MCP_RESTART_DEFAULT_TIMEOUT_MS
+    );
+  }
+  reload(opts) {
+    return this.post(
+      "/reload",
+      "POST /workspaces/:workspace/reload",
+      {},
+      opts?.clientId,
+      opts?.timeoutMs
+    );
+  }
+  initWorkspace(opts) {
+    return this.post(
+      "/init",
+      "POST /workspaces/:workspace/init",
+      opts?.force === true ? { force: true } : {},
+      opts?.clientId
+    );
+  }
+  workspaceExtensions() {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      "/extensions",
+      "GET /workspaces/:workspace/extensions",
+      { mode: "rest" }
+    );
+  }
+  setExtensionActivation(extensionId, state, clientId) {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      `/extensions/${urlEncode(extensionId)}/activation`,
+      "PUT /workspaces/:workspace/extensions/:extensionId/activation",
+      { method: "PUT", body: { state }, clientId, mode: "rest" }
+    );
+  }
+  clearExtensionActivation(extensionId, clientId) {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      `/extensions/${urlEncode(extensionId)}/activation`,
+      "DELETE /workspaces/:workspace/extensions/:extensionId/activation",
+      { method: "DELETE", clientId, mode: "rest" }
+    );
+  }
+  refreshExtensionRuntime(clientId) {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      "/extensions/refresh",
+      "POST /workspaces/:workspace/extensions/refresh",
+      { method: "POST", body: {}, clientId, mode: "rest" }
+    );
+  }
+  get(path, label, clientId) {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      path,
+      label,
+      { clientId }
+    );
+  }
+  post(path, label, body, clientId, timeoutMs) {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      path,
+      label,
+      { method: "POST", body, clientId, timeoutMs }
+    );
+  }
+};
 function composeAbortSignals2(signals) {
   const anyFn = AbortSignal.any;
   if (typeof anyFn === "function") return anyFn.call(AbortSignal, signals);
@@ -2807,7 +3713,7 @@ var DaemonSessionClient = class _DaemonSessionClient {
    */
   static async createOrAttach(client, req = {}, clientId) {
     const session = await client.createOrAttachSession(req, clientId);
-    const lastEventId = !session.attached || req.modelServiceId ? 0 : void 0;
+    const lastEventId = !session.attached || req.modelServiceId || req.approvalMode ? 0 : void 0;
     return new _DaemonSessionClient({
       client,
       session,
@@ -3110,6 +4016,9 @@ var DaemonSessionClient = class _DaemonSessionClient {
   async context() {
     return await this.client.sessionContext(this.sessionId, this.clientId);
   }
+  async status() {
+    return await this.client.sessionStatus(this.sessionId, this.clientId);
+  }
   async contextUsage(opts = {}) {
     return await this.client.sessionContextUsage(
       this.sessionId,
@@ -3304,6 +4213,7 @@ var DAEMON_KNOWN_EVENT_TYPE_VALUES = [
   "session_died",
   "session_closed",
   "session_metadata_updated",
+  "session_recording_degraded",
   "artifact_changed",
   MID_TURN_MESSAGE_INJECTED_EVENT,
   PENDING_PROMPT_ADDED_EVENT,
@@ -3414,7 +4324,8 @@ var DAEMON_KNOWN_EVENT_TYPE_VALUES = [
   // `replay_complete` when `?snapshot=1` is set on the SSE endpoint.
   // Carries `currentModelId` and `currentApprovalMode` so reconnecting
   // clients can seed their reducer without an extra round-trip.
-  "session_snapshot"
+  "session_snapshot",
+  "git_branch_changed"
 ];
 var DAEMON_KNOWN_EVENT_TYPES = new Set(
   DAEMON_KNOWN_EVENT_TYPE_VALUES
@@ -3428,6 +4339,7 @@ var RESYNC_PASSTHROUGH_TYPES = /* @__PURE__ */ new Set([
   "session_closed",
   "client_evicted",
   "stream_error",
+  "session_recording_degraded",
   // A5 (#4511): the snapshot is a full-state authoritative frame, not a
   // delta, so it is safe to apply during resync — and it is exactly what
   // lets a client that reconnected past the ring recover currentModelId /
@@ -3442,6 +4354,7 @@ function createDaemonSessionViewState(seed = {}) {
     sessionId: seed.sessionId,
     currentModelId: seed.currentModelId,
     displayName: seed.displayName,
+    recordingDegraded: seed.recordingDegraded ?? false,
     lastSessionUpdate: seed.lastSessionUpdate,
     lastModelSwitchFailure: seed.lastModelSwitchFailure,
     terminalEvent: seed.terminalEvent,
@@ -3527,6 +4440,8 @@ function asKnownDaemonEvent(event) {
       return isSessionClosedData(event.data) ? event : void 0;
     case "session_metadata_updated":
       return isSessionMetadataUpdatedData(event.data) ? event : void 0;
+    case "session_recording_degraded":
+      return isSessionRecordingDegradedData(event.data) ? event : void 0;
     case "artifact_changed":
       return isArtifactChangedData(event.data) ? event : void 0;
     case MID_TURN_MESSAGE_INJECTED_EVENT:
@@ -3909,7 +4824,14 @@ function reduceDaemonSessionEvent(state, rawEvent) {
         ...base,
         sessionId: event.data.sessionId,
         ...event.data.currentModelId != null ? { currentModelId: event.data.currentModelId } : {},
-        ...event.data.currentApprovalMode != null ? { approvalMode: event.data.currentApprovalMode } : {}
+        ...event.data.currentApprovalMode != null ? { approvalMode: event.data.currentApprovalMode } : {},
+        ...event.data.recordingDegraded !== void 0 ? { recordingDegraded: event.data.recordingDegraded } : {}
+      };
+    case "session_recording_degraded":
+      return {
+        ...base,
+        sessionId: event.data.sessionId,
+        recordingDegraded: true
       };
     case "session_branched":
       return {
@@ -4153,7 +5075,7 @@ function isStateResyncRequiredData(value) {
 }
 __name(isStateResyncRequiredData, "isStateResyncRequiredData");
 function isHistoryTruncatedData(value) {
-  if (!isRecord(value) || value["reason"] !== "replay_window_exceeded" || !isFiniteNumber(value["truncatedEvents"]) || !isFiniteNumber(value["retainedEvents"]) || !isFiniteNumber(value["maxBytes"]) || value["fullTranscriptAvailable"] !== false) {
+  if (!isRecord(value) || value["reason"] !== "replay_window_exceeded" || !isFiniteNumber(value["truncatedEvents"]) || !isFiniteNumber(value["retainedEvents"]) || !isFiniteNumber(value["maxBytes"]) || typeof value["fullTranscriptAvailable"] !== "boolean") {
     return false;
   }
   const truncatedTurns = value["truncatedTurns"];
@@ -4370,9 +5292,14 @@ function isSessionSnapshotData(value) {
   if (!isRecord(value) || !isNonEmptyString(value["sessionId"])) return false;
   const model = value["currentModelId"];
   const mode = value["currentApprovalMode"];
-  return (model === null || typeof model === "string") && (mode === null || typeof mode === "string");
+  const recordingDegraded = value["recordingDegraded"];
+  return (model === null || typeof model === "string") && (mode === null || typeof mode === "string") && (recordingDegraded === void 0 || typeof recordingDegraded === "boolean");
 }
 __name(isSessionSnapshotData, "isSessionSnapshotData");
+function isSessionRecordingDegradedData(value) {
+  return isRecord(value) && isNonEmptyString(value["sessionId"]) && value["reason"] === "write_failed";
+}
+__name(isSessionRecordingDegradedData, "isSessionRecordingDegradedData");
 function isPermissionOption(value) {
   return isRecord(value) && isNonEmptyString(value["optionId"]);
 }
@@ -4700,6 +5627,7 @@ var MCP_RESTART_REFUSED_REASONS2 = /* @__PURE__ */ new Set([
 ]);
 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.";
 function normalizeDaemonEvent(event, opts = {}) {
   const base = createBase(event, opts);
   switch (event.type) {
@@ -4760,6 +5688,42 @@ function normalizeDaemonEvent(event, opts = {}) {
           text: `Session closed: ${getString2(event.data, "reason") ?? "closed"}`
         }
       ];
+    case "session_recording_degraded": {
+      const sessionId = getString2(event.data, "sessionId");
+      if (!sessionId || getString2(event.data, "reason") !== "write_failed") {
+        return fallbackDebug(event, base, "malformed recording state");
+      }
+      return [
+        {
+          ...base,
+          type: "error",
+          recoverable: true,
+          code: "session_recording_degraded",
+          text: SESSION_RECORDING_DEGRADED_MESSAGE
+        }
+      ];
+    }
+    case "session_snapshot": {
+      if (!isRecord2(event.data) || !getString2(event.data, "sessionId")) {
+        return fallbackDebug(event, base, "malformed recording snapshot");
+      }
+      const recordingDegraded = event.data["recordingDegraded"];
+      if (recordingDegraded !== void 0 && typeof recordingDegraded !== "boolean") {
+        return fallbackDebug(event, base, "malformed recording snapshot");
+      }
+      if (recordingDegraded === true) {
+        return [
+          {
+            ...base,
+            type: "error",
+            recoverable: true,
+            code: "session_recording_degraded",
+            text: SESSION_RECORDING_DEGRADED_MESSAGE
+          }
+        ];
+      }
+      return [];
+    }
     case "client_evicted":
       return [
         {
@@ -4865,6 +5829,8 @@ function normalizeDaemonEvent(event, opts = {}) {
     case "approval_mode_changed":
       return normalizeApprovalModeChanged(event, base);
     // ── Workspace events ──────────────────────────────────────
+    case "git_branch_changed":
+      return [];
     case "memory_changed":
       return normalizeMemoryChanged(event, base);
     case "agent_changed":
@@ -4891,6 +5857,8 @@ function normalizeDaemonEvent(event, opts = {}) {
       return normalizeMcpServerRestartRefused(event, base);
     case "extensions_changed":
       return normalizeExtensionsChanged(event, base);
+    case "artifact_changed":
+      return normalizeArtifactChanged(event, base);
     // ── Auth device-flow events (RFC 8628) ─────────────────
     case "auth_device_flow_started":
       return normalizeAuthDeviceFlowStarted(event, base);
@@ -4903,16 +5871,20 @@ function normalizeDaemonEvent(event, opts = {}) {
     case "auth_device_flow_cancelled":
       return normalizeAuthDeviceFlowCancelled(event, base);
     default:
-      return [
-        {
-          ...base,
-          type: "debug",
-          text: `${event.type} (unrecognized daemon event): ${stringifyRedactedJson(event.data)}`
-        }
-      ];
+      return normalizeUnrecognizedEvent(event, base);
   }
 }
 __name(normalizeDaemonEvent, "normalizeDaemonEvent");
+function normalizeUnrecognizedEvent(event, base) {
+  return [
+    {
+      ...base,
+      type: "debug",
+      text: `${event.type} (unrecognized daemon event): ${stringifyRedactedJson(event.data)}`
+    }
+  ];
+}
+__name(normalizeUnrecognizedEvent, "normalizeUnrecognizedEvent");
 function normalizeStateResyncRequired(event, base) {
   const reason = getString2(event.data, "reason");
   const lastDeliveredId = numberField(event.data, "lastDeliveredId");
@@ -4940,7 +5912,7 @@ function normalizeHistoryTruncated(event, base) {
   const truncatedEvents = numberField(event.data, "truncatedEvents");
   const retainedEvents = numberField(event.data, "retainedEvents");
   const maxBytes = numberField(event.data, "maxBytes");
-  if (reason !== "replay_window_exceeded" || truncatedEvents === void 0 || retainedEvents === void 0 || maxBytes === void 0 || isRecord2(event.data) && event.data["fullTranscriptAvailable"] !== false) {
+  if (reason !== "replay_window_exceeded" || truncatedEvents === void 0 || retainedEvents === void 0 || maxBytes === void 0 || !isRecord2(event.data) || typeof event.data["fullTranscriptAvailable"] !== "boolean") {
     return fallbackDebug(event, base, "malformed history_truncated payload");
   }
   return [
@@ -5166,8 +6138,13 @@ function normalizeSessionUpdate(event, base, opts) {
       ];
     }
     case "tool_call":
-    case "tool_call_update":
+    case "tool_call_update": {
+      const meta = isRecord2(update["_meta"]) ? update["_meta"] : void 0;
+      if (getString2(update, "status") === "in_progress" && getString2(update, "kind") === void 0 && meta?.["shellProgress"] !== void 0) {
+        return [];
+      }
       return [normalizeToolUpdate(update, base)];
+    }
     case "shell_output":
     case "tool_output": {
       const text = getOutputText(update);
@@ -5488,6 +6465,27 @@ function normalizeSessionMetadataUpdated(event, base) {
   ];
 }
 __name(normalizeSessionMetadataUpdated, "normalizeSessionMetadataUpdated");
+function normalizeArtifactChanged(event, base) {
+  const sessionId = getString2(event.data, "sessionId");
+  const change = isRecord2(event.data) ? event.data["change"] : void 0;
+  if (!sessionId || !isRecord2(change)) {
+    return fallbackDebug(event, base, "malformed artifact_changed payload");
+  }
+  const action = getString2(change, "action");
+  const artifactId = getString2(change, "artifactId");
+  if (!action || !artifactId) {
+    return fallbackDebug(event, base, "missing action or artifactId");
+  }
+  return [
+    {
+      ...base,
+      type: "session.artifact.changed",
+      sessionId,
+      change
+    }
+  ];
+}
+__name(normalizeArtifactChanged, "normalizeArtifactChanged");
 function normalizeApprovalModeChanged(event, base) {
   const sessionId = getString2(event.data, "sessionId");
   const previous = getString2(event.data, "previous");
@@ -6348,7 +7346,14 @@ var RESYNC_PASSTHROUGH_TYPES2 = /* @__PURE__ */ new Set([
 function appendLocalUserTranscriptMessage(state, text, opts = {}) {
   const next = cloneTranscriptState(state, opts);
   finishAssistant(next);
-  const block = createTextBlock(next, "user", text);
+  const block = createTextBlock(
+    next,
+    "user",
+    text,
+    void 0,
+    void 0,
+    opts.meta
+  );
   if (opts.images && opts.images.length > 0) {
     block.images = [...opts.images];
   }
@@ -6487,6 +7492,7 @@ function applyDaemonTranscriptEvent(next, event) {
       next.approvalMode = event.next;
       break;
     case "session.metadata.changed":
+    case "session.artifact.changed":
     case "session.available_commands":
       break;
     case "session.state_resync_required":
@@ -7441,8 +8447,8 @@ function createDaemonTranscriptStore(seed = {}) {
       state = reduceDaemonTranscriptEvents(state, events);
       scheduleNotify();
     },
-    appendLocalUserMessage(text, images) {
-      state = appendLocalUserTranscriptMessage(state, text, { images });
+    appendLocalUserMessage(text, images, meta) {
+      state = appendLocalUserTranscriptMessage(state, text, { images, meta });
       scheduleNotify();
     },
     reset(nextSeed = {}) {
@@ -7587,6 +8593,12 @@ function daemonUiEventToTerminalText(event) {
         `metadata: ${event.displayName ?? "(no display name)"}`,
         "36"
       );
+    case "session.artifact.changed":
+      return terminalLine(
+        "artifact",
+        `${event.change.action} ${event.change.artifact?.title ?? event.change.artifactId}`,
+        "36"
+      );
     case "session.approval_mode.changed":
       return terminalLine(
         "approval-mode",
@@ -8691,6 +9703,7 @@ export {
   PENDING_PROMPT_COMPLETED_EVENT,
   PENDING_PROMPT_STARTED_EVENT,
   SseFramingError,
+  WorkspaceDaemonClient,
   appendLocalUserTranscriptMessage,
   asKnownDaemonEvent,
   createDaemonAuthState,