@qwen-code/qwen-code 0.22.2 → 0.22.3-nightly.20260831.3a0c4c6108

package/chunks/{daemon-MJQUO7RA.js → daemon-UCVUHPJD.js}

@@ -23,6 +23,47 @@ var MCP_RESTART_CLIENT_HEADROOM_MS = 3e4;
 
 // packages/sdk-typescript/src/daemon/DaemonAuthFlow.ts
 init_esbuild_shims();
+
+// packages/sdk-typescript/src/daemon/DaemonHttpError.ts
+init_esbuild_shims();
+var DaemonHttpError = class extends Error {
+  static {
+    __name(this, "DaemonHttpError");
+  }
+  status;
+  body;
+  constructor(status, body, message) {
+    super(message);
+    this.name = "DaemonHttpError";
+    this.status = status;
+    this.body = body;
+  }
+};
+function getErrorBodyRecord(body) {
+  return typeof body === "object" && body !== null && !Array.isArray(body) ? body : void 0;
+}
+__name(getErrorBodyRecord, "getErrorBodyRecord");
+function isSubagentSessionNotFound(error, toolCallId) {
+  if (!(error instanceof DaemonHttpError) || error.status !== 404) {
+    return false;
+  }
+  const body = getErrorBodyRecord(error.body);
+  if (body?.["code"] !== "session_not_found") return false;
+  return toolCallId === void 0 || body["toolCallId"] === toolCallId;
+}
+__name(isSubagentSessionNotFound, "isSubagentSessionNotFound");
+function isSessionLevelNotFound(error) {
+  if (!(error instanceof DaemonHttpError) || error.status !== 404) {
+    return false;
+  }
+  const body = getErrorBodyRecord(error.body);
+  if (body?.["code"] !== "session_not_found") return false;
+  const toolCallId = body["toolCallId"];
+  return toolCallId === void 0 || toolCallId === null;
+}
+__name(isSessionLevelNotFound, "isSessionLevelNotFound");
+
+// packages/sdk-typescript/src/daemon/DaemonAuthFlow.ts
 var DEVICE_FLOW_EXPIRY_GRACE_MS = 3e4;
 var TERMINAL_STATUSES = /* @__PURE__ */ new Set(
   ["authorized", "expired", "error", "cancelled"]
@@ -181,49 +222,10 @@ function isDaemonSessionPrInfo(value) {
   const v = value;
   return typeof v["number"] === "number" && Number.isInteger(v["number"]) && v["number"] > 0 && typeof v["url"] === "string" && v["url"].length <= MAX_SESSION_PR_URL_LENGTH && /^https?:\/\//i.test(v["url"]) && // The daemon interpolates the url into a stderr audit line — control
   // characters would forge log lines downstream of this gate.
-  !hasControlCharacter(v["url"]);
+  !hasControlCharacter(v["url"]) && (v["state"] === void 0 || v["state"] === "open" || v["state"] === "merged" || v["state"] === "closed");
 }
 __name(isDaemonSessionPrInfo, "isDaemonSessionPrInfo");
 
-// packages/sdk-typescript/src/daemon/DaemonHttpError.ts
-init_esbuild_shims();
-var DaemonHttpError = class extends Error {
-  static {
-    __name(this, "DaemonHttpError");
-  }
-  status;
-  body;
-  constructor(status, body, message) {
-    super(message);
-    this.name = "DaemonHttpError";
-    this.status = status;
-    this.body = body;
-  }
-};
-function getErrorBodyRecord(body) {
-  return typeof body === "object" && body !== null && !Array.isArray(body) ? body : void 0;
-}
-__name(getErrorBodyRecord, "getErrorBodyRecord");
-function isSubagentSessionNotFound(error, toolCallId) {
-  if (!(error instanceof DaemonHttpError) || error.status !== 404) {
-    return false;
-  }
-  const body = getErrorBodyRecord(error.body);
-  if (body?.["code"] !== "session_not_found") return false;
-  return toolCallId === void 0 || body["toolCallId"] === toolCallId;
-}
-__name(isSubagentSessionNotFound, "isSubagentSessionNotFound");
-function isSessionLevelNotFound(error) {
-  if (!(error instanceof DaemonHttpError) || error.status !== 404) {
-    return false;
-  }
-  const body = getErrorBodyRecord(error.body);
-  if (body?.["code"] !== "session_not_found") return false;
-  const toolCallId = body["toolCallId"];
-  return toolCallId === void 0 || toolCallId === null;
-}
-__name(isSessionLevelNotFound, "isSessionLevelNotFound");
-
 // packages/sdk-typescript/src/daemon/RestSseTransport.ts
 init_esbuild_shims();
 
@@ -624,6 +626,232 @@ function isDaemonContentHash(value) {
 __name(isDaemonContentHash, "isDaemonContentHash");
 var DAEMON_APPROVAL_MODES = PERMISSION_MODES;
 
+// packages/sdk-typescript/src/daemon/standalone-sessions.ts
+init_esbuild_shims();
+var STANDALONE_SESSIONS_CAPABILITY = "standalone_sessions_v1";
+var DaemonStandaloneProtocolError = class extends Error {
+  constructor(route, detail) {
+    super(`${route}: malformed standalone-session response (${detail})`);
+    this.route = route;
+    this.name = "DaemonStandaloneProtocolError";
+  }
+  static {
+    __name(this, "DaemonStandaloneProtocolError");
+  }
+};
+var DaemonStandaloneCreationOutcomeUnknownError = class extends Error {
+  constructor(sessionId, recovery, originalError) {
+    super(
+      `Standalone session creation outcome is unknown for ${sessionId}; inspect recovery before retrying.`
+    );
+    this.sessionId = sessionId;
+    this.recovery = recovery;
+    this.originalError = originalError;
+    this.name = "DaemonStandaloneCreationOutcomeUnknownError";
+  }
+  static {
+    __name(this, "DaemonStandaloneCreationOutcomeUnknownError");
+  }
+};
+function asRecord(value, route, field = "response") {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new DaemonStandaloneProtocolError(route, `expected ${field} object`);
+  }
+  return value;
+}
+__name(asRecord, "asRecord");
+function requireString(value, field, route, allowEmpty = false) {
+  const result = value[field];
+  if (typeof result !== "string" || !allowEmpty && result.length === 0) {
+    throw new DaemonStandaloneProtocolError(route, `expected ${field} string`);
+  }
+  return result;
+}
+__name(requireString, "requireString");
+function requireStringArray(value, field, route) {
+  const result = value[field];
+  if (!Array.isArray(result) || !result.every((item) => typeof item === "string")) {
+    throw new DaemonStandaloneProtocolError(route, `expected ${field}[]`);
+  }
+}
+__name(requireStringArray, "requireStringArray");
+function requireSessionId(value, route, expected) {
+  const sessionId = requireString(value, "sessionId", route);
+  if (expected !== void 0 && sessionId !== expected) {
+    throw new DaemonStandaloneProtocolError(
+      route,
+      `expected sessionId ${expected}, received ${sessionId}`
+    );
+  }
+  return sessionId;
+}
+__name(requireSessionId, "requireSessionId");
+function validateContext(value, route) {
+  if (asRecord(value["context"], route, "context")["kind"] !== "standalone") {
+    throw new DaemonStandaloneProtocolError(
+      route,
+      "expected standalone context"
+    );
+  }
+}
+__name(validateContext, "validateContext");
+function validateWorkingDirectory(value, route) {
+  const directory = asRecord(value, route, "workingDirectory");
+  if (directory["state"] !== "ready" && directory["state"] !== "recreated") {
+    throw new DaemonStandaloneProtocolError(
+      route,
+      "invalid workingDirectory.state"
+    );
+  }
+  if (directory["warnings"] !== void 0) {
+    requireStringArray(directory, "warnings", route);
+  }
+}
+__name(validateWorkingDirectory, "validateWorkingDirectory");
+function validateStandaloneFields(value, route) {
+  if (value["sourceType"] !== "standalone") {
+    throw new DaemonStandaloneProtocolError(
+      route,
+      "expected standalone sourceType"
+    );
+  }
+  validateContext(value, route);
+  requireString(value, "projectlessOutputDirectory", route);
+  validateWorkingDirectory(value["workingDirectory"], route);
+}
+__name(validateStandaloneFields, "validateStandaloneFields");
+function parseStandaloneSession(value, route, expectedSessionId) {
+  const session = asRecord(value, route);
+  requireSessionId(session, route, expectedSessionId);
+  requireString(session, "workspaceCwd", route);
+  if (typeof session["attached"] !== "boolean") {
+    throw new DaemonStandaloneProtocolError(route, "expected attached boolean");
+  }
+  validateStandaloneFields(session, route);
+  return session;
+}
+__name(parseStandaloneSession, "parseStandaloneSession");
+function parseRestoredStandaloneSession(value, route, expectedSessionId) {
+  const raw = asRecord(value, route);
+  parseStandaloneSession(raw, route, expectedSessionId);
+  asRecord(raw["state"], route, "state");
+  return raw;
+}
+__name(parseRestoredStandaloneSession, "parseRestoredStandaloneSession");
+function parseStandaloneSummary(value, route, expectedSessionId) {
+  const summary = asRecord(value, route);
+  requireSessionId(summary, route, expectedSessionId);
+  requireString(summary, "workspaceCwd", route);
+  if (summary["sourceType"] !== "standalone") {
+    throw new DaemonStandaloneProtocolError(
+      route,
+      "expected standalone sourceType"
+    );
+  }
+  validateContext(summary, route);
+  return summary;
+}
+__name(parseStandaloneSummary, "parseStandaloneSummary");
+function parseStandaloneLookup(value, route, expectedSessionId) {
+  const lookup = asRecord(value, route);
+  if (lookup["state"] === "creating") {
+    const sessionId = requireSessionId(lookup, route, expectedSessionId);
+    return { sessionId, state: "creating" };
+  }
+  return parseStandaloneSummary(lookup, route, expectedSessionId);
+}
+__name(parseStandaloneLookup, "parseStandaloneLookup");
+function parseStandaloneListPage(value, route) {
+  const page = asRecord(value, route);
+  if (!Array.isArray(page["sessions"])) {
+    throw new DaemonStandaloneProtocolError(route, "expected sessions[]");
+  }
+  if (page["nextCursor"] !== void 0 && typeof page["nextCursor"] !== "string") {
+    throw new DaemonStandaloneProtocolError(
+      route,
+      "expected nextCursor string"
+    );
+  }
+  for (const field of ["liveMergeFailed", "truncated"]) {
+    if (page[field] !== void 0 && typeof page[field] !== "boolean") {
+      throw new DaemonStandaloneProtocolError(
+        route,
+        `expected ${field} boolean`
+      );
+    }
+  }
+  for (const session of page["sessions"])
+    parseStandaloneSummary(session, route);
+  return page;
+}
+__name(parseStandaloneListPage, "parseStandaloneListPage");
+function parseStandaloneDirectoryResult(value, route, expectedSessionId) {
+  const result = asRecord(value, route);
+  requireSessionId(result, route, expectedSessionId);
+  requireString(result, "projectlessOutputDirectory", route);
+  validateWorkingDirectory(result["workingDirectory"], route);
+  return result;
+}
+__name(parseStandaloneDirectoryResult, "parseStandaloneDirectoryResult");
+function parseStandaloneMetadataResult(value, route, expectedSessionId) {
+  const result = asRecord(value, route);
+  requireSessionId(result, route, expectedSessionId);
+  requireString(result, "displayName", route, true);
+  return result;
+}
+__name(parseStandaloneMetadataResult, "parseStandaloneMetadataResult");
+function validateBatch(value, route, fields) {
+  const result = asRecord(value, route);
+  for (const field of fields) requireStringArray(result, field, route);
+  if (!Array.isArray(result["errors"])) {
+    throw new DaemonStandaloneProtocolError(route, "expected errors[]");
+  }
+  for (const item of result["errors"]) {
+    const error = asRecord(item, route, "batch error");
+    for (const field of ["sessionId", "code", "message"]) {
+      requireString(error, field, route);
+    }
+  }
+  return result;
+}
+__name(validateBatch, "validateBatch");
+function parseArchiveStandaloneSessionsResult(value, route) {
+  return validateBatch(value, route, [
+    "archived",
+    "alreadyArchived",
+    "notFound"
+  ]);
+}
+__name(parseArchiveStandaloneSessionsResult, "parseArchiveStandaloneSessionsResult");
+function parseUnarchiveStandaloneSessionsResult(value, route) {
+  return validateBatch(value, route, [
+    "unarchived",
+    "alreadyActive",
+    "notFound"
+  ]);
+}
+__name(parseUnarchiveStandaloneSessionsResult, "parseUnarchiveStandaloneSessionsResult");
+function parseDeleteStandaloneSessionsResult(value, route) {
+  return validateBatch(value, route, [
+    "removed",
+    "notFound",
+    "fileCleanupPending"
+  ]);
+}
+__name(parseDeleteStandaloneSessionsResult, "parseDeleteStandaloneSessionsResult");
+function isStandaloneSessionNotFoundError(error) {
+  return error instanceof DaemonHttpError && error.status === 404 && recordCode(error.body) === "standalone_session_not_found";
+}
+__name(isStandaloneSessionNotFoundError, "isStandaloneSessionNotFoundError");
+function isStandaloneCreationOutcomeUnknown(error) {
+  return error instanceof DaemonStandaloneCreationOutcomeUnknownError || error instanceof DaemonHttpError && recordCode(error.body) === "standalone_creation_outcome_unknown";
+}
+__name(isStandaloneCreationOutcomeUnknown, "isStandaloneCreationOutcomeUnknown");
+function recordCode(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value["code"] : void 0;
+}
+__name(recordCode, "recordCode");
+
 // packages/sdk-typescript/src/daemon/DaemonClient.ts
 var WORKSPACE_MEMORY_REMEMBER_PATH = "/workspace/memory/remember";
 var WORKSPACE_MEMORY_FORGET_PATH = "/workspace/memory/forget";
@@ -665,11 +893,15 @@ function parseSessionGenerationEvent(value) {
 __name(parseSessionGenerationEvent, "parseSessionGenerationEvent");
 var DEFAULT_SESSION_LIST_PAGE_SIZE = 20;
 var DEFAULT_FETCH_TIMEOUT_MS = 3e4;
+var DEFAULT_PROVIDER_MUTATION_TIMEOUT_MS = 0;
 var DEFAULT_SESSION_RESTORE_TIMEOUT_MS = 7e4;
 var SESSION_RESTORE_TIMEOUT_HEADROOM_MS = 1e4;
 var VOICE_TRANSCRIPTION_DEFAULT_TIMEOUT_MS = 65e3;
 var GITHUB_SETUP_DEFAULT_TIMEOUT_MS = 9e4;
 var CHANNEL_NOTIFY_DEFAULT_TIMEOUT_MS = 35e3;
+var WORKSPACE_RUNTIME_ENSURE_SERVER_DEADLINE_MS = 6e4;
+var WORKSPACE_RUNTIME_ENSURE_CLIENT_HEADROOM_MS = 2e3;
+var WORKSPACE_RUNTIME_ENSURE_TIMEOUT_MS = WORKSPACE_RUNTIME_ENSURE_SERVER_DEADLINE_MS + WORKSPACE_RUNTIME_ENSURE_CLIENT_HEADROOM_MS;
 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;
@@ -880,7 +1112,23 @@ var DaemonClient = class {
       }
     } catch {
     }
-    const detail = body && typeof body === "object" && "error" in body ? String(body.error) : `HTTP ${res.status}`;
+    const errorBody = body && typeof body === "object" && !Array.isArray(body) ? body : void 0;
+    let detail = errorBody && "error" in errorBody ? String(errorBody["error"]) : `HTTP ${res.status}`;
+    if (res.status >= 500 && errorBody?.["error"] === "Internal error" && typeof errorBody["code"] === "number") {
+      const data = errorBody["data"];
+      if (typeof data === "string" && data.length > 0) {
+        detail = data;
+      } else if (data && typeof data === "object" && !Array.isArray(data)) {
+        const record = data;
+        const details = record["details"];
+        const message = record["message"];
+        if (typeof details === "string" && details.length > 0) {
+          detail = details;
+        } else if (typeof message === "string" && message.length > 0) {
+          detail = message;
+        }
+      }
+    }
     if (sessionId && res.status === 503 && body && typeof body === "object") {
       const data = body;
       if (data.code === "prompt_queue_full") {
@@ -1249,6 +1497,24 @@ var DaemonClient = class {
       { mode: "rest" }
     );
   }
+  async ensureWorkspaceRuntime() {
+    return await this.jsonRequest(
+      "/workspace/runtime/ensure",
+      "POST /workspace/runtime/ensure",
+      {
+        method: "POST",
+        timeoutMs: WORKSPACE_RUNTIME_ENSURE_TIMEOUT_MS,
+        mode: "rest"
+      }
+    );
+  }
+  async workspaceRuntimeStatus() {
+    return await this.jsonRequest(
+      "/workspace/runtime/status",
+      "GET /workspace/runtime/status",
+      { mode: "rest" }
+    );
+  }
   async workspaceProviders() {
     return await this.fetchWithTimeout(
       `${this.baseUrl}/workspace/providers`,
@@ -1551,22 +1817,21 @@ var DaemonClient = class {
   }
   // -- Workspace files (workspace files) -------------------------------
   async readWorkspaceFile(filePath, opts = {}, clientId) {
-    const url = new URL(`${this.baseUrl}/file`);
-    url.searchParams.set("path", filePath);
+    const query = new URLSearchParams({ path: filePath });
     if (opts.maxBytes !== void 0) {
-      url.searchParams.set("maxBytes", String(opts.maxBytes));
+      query.set("maxBytes", String(opts.maxBytes));
     }
     if (opts.line !== void 0) {
-      url.searchParams.set("line", String(opts.line));
+      query.set("line", String(opts.line));
     }
     if (opts.limit !== void 0) {
-      url.searchParams.set("limit", String(opts.limit));
+      query.set("limit", String(opts.limit));
     }
     if (opts.cursor !== void 0) {
-      url.searchParams.set("cursor", opts.cursor);
+      query.set("cursor", opts.cursor);
     }
     return await this.fetchWithTimeout(
-      url.toString(),
+      `${this.baseUrl}/file?${query.toString()}`,
       { headers: this.headers({}, clientId) },
       async (res) => {
         if (!res.ok) throw await this.failOnError(res, "GET /file");
@@ -1592,10 +1857,9 @@ var DaemonClient = class {
     );
   }
   async fileStat(filePath) {
-    const url = new URL(`${this.baseUrl}/stat`);
-    url.searchParams.set("path", filePath);
+    const query = new URLSearchParams({ path: filePath });
     return await this.fetchWithTimeout(
-      url.toString(),
+      `${this.baseUrl}/stat?${query.toString()}`,
       { headers: this.headers() },
       async (res) => {
         if (!res.ok) throw await this.failOnError(res, "GET /stat");
@@ -1604,10 +1868,9 @@ var DaemonClient = class {
     );
   }
   async dirList(dirPath) {
-    const url = new URL(`${this.baseUrl}/list`);
-    url.searchParams.set("path", dirPath);
+    const query = new URLSearchParams({ path: dirPath });
     return await this.fetchWithTimeout(
-      url.toString(),
+      `${this.baseUrl}/list?${query.toString()}`,
       { headers: this.headers() },
       async (res) => {
         if (!res.ok) throw await this.failOnError(res, "GET /list");
@@ -1620,10 +1883,9 @@ var DaemonClient = class {
    * pick a path outside any registered workspace (e.g. "Add workspace").
    */
   async workspacePathSuggestions(prefix) {
-    const url = new URL(`${this.baseUrl}/workspace-path-suggestions`);
-    url.searchParams.set("prefix", prefix);
+    const query = new URLSearchParams({ prefix });
     return await this.fetchWithTimeout(
-      url.toString(),
+      `${this.baseUrl}/workspace-path-suggestions?${query.toString()}`,
       { headers: this.headers() },
       async (res) => {
         if (!res.ok) {
@@ -1646,10 +1908,9 @@ var DaemonClient = class {
     );
   }
   async glob(pattern) {
-    const url = new URL(`${this.baseUrl}/glob`);
-    url.searchParams.set("pattern", pattern);
+    const query = new URLSearchParams({ pattern });
     return await this.fetchWithTimeout(
-      url.toString(),
+      `${this.baseUrl}/glob?${query.toString()}`,
       { headers: this.headers() },
       async (res) => {
         if (!res.ok) throw await this.failOnError(res, "GET /glob");
@@ -1699,9 +1960,8 @@ var DaemonClient = class {
    * @internal
    */
   async uploadFileToPath(uploadPath, label, req, clientId) {
-    const target = new URL(`${this.baseUrl}${uploadPath}`);
-    target.searchParams.set("path", req.path);
-    const url = target.toString();
+    const query = new URLSearchParams({ path: req.path });
+    const url = `${this.baseUrl}${uploadPath}?${query.toString()}`;
     const headers = this.headers(
       { "Content-Type": "application/octet-stream" },
       clientId
@@ -1854,10 +2114,11 @@ var DaemonClient = class {
   }
   /**
    * Append to or replace `QWEN.md` at workspace or global scope.
-   * Strict mutation gate (`token_required` on no-token loopback
-   * defaults). When the daemon advertises `workspace_memory`, expect
-   * 200 with `{ ok, filePath, bytesWritten, mode }`; older daemons
-   * without the capability return 404.
+   * The strict mutation gate accepts trusted-loopback callers without a token;
+   * older daemons and non-trusted embeds can still return `token_required`.
+   * When the daemon advertises `workspace_memory`, expect 200 with
+   * `{ ok, filePath, bytesWritten, mode }`; older daemons without the
+   * capability return 404.
    */
   async writeWorkspaceMemory(req, clientId) {
     return await this.fetchWithTimeout(
@@ -1881,6 +2142,11 @@ var DaemonClient = class {
    * poll `getWorkspaceMemoryRememberTask()` until the task is terminal.
    */
   async rememberWorkspaceMemory(content, opts = {}) {
+    if (opts.scope) {
+      await this.requireCapability(
+        opts.scope === "project" ? "workspace_memory_remember_project_scope" : "workspace_memory_remember_user_scope"
+      );
+    }
     return await this.jsonRequest(
       WORKSPACE_MEMORY_REMEMBER_PATH,
       `POST ${WORKSPACE_MEMORY_REMEMBER_PATH}`,
@@ -1888,7 +2154,8 @@ var DaemonClient = class {
         method: "POST",
         body: {
           content,
-          contextMode: opts.contextMode ?? "workspace"
+          contextMode: opts.contextMode ?? "workspace",
+          ...opts.scope ? { scope: opts.scope } : {}
         },
         clientId: opts.clientId
       }
@@ -1902,12 +2169,18 @@ var DaemonClient = class {
     );
   }
   async forgetWorkspaceMemory(query, opts = {}) {
+    if (opts.scope) {
+      await this.requireCapability("workspace_memory_forget_scope");
+    }
     return await this.jsonRequest(
       WORKSPACE_MEMORY_FORGET_PATH,
       `POST ${WORKSPACE_MEMORY_FORGET_PATH}`,
       {
         method: "POST",
-        body: { query },
+        body: {
+          query,
+          ...opts.scope ? { scope: opts.scope } : {}
+        },
         clientId: opts.clientId
       }
     );
@@ -2142,6 +2415,185 @@ var DaemonClient = class {
     );
   }
   // -- Sessions ----------------------------------------------------------
+  async createStandaloneSession(options = {}) {
+    await this.requireCapability(STANDALONE_SESSIONS_CAPABILITY);
+    const { sessionId: requestedSessionId, ...request } = options;
+    const sessionId = (requestedSessionId ?? globalThis.crypto.randomUUID()).toLowerCase();
+    try {
+      const response = await this.jsonRequest(
+        "/standalone/sessions",
+        "POST /standalone/sessions",
+        {
+          method: "POST",
+          body: { sessionId, ...request },
+          mode: "rest"
+        }
+      );
+      return parseStandaloneSession(
+        response,
+        "POST /standalone/sessions",
+        sessionId
+      );
+    } catch (error) {
+      if (error instanceof DaemonHttpError && !isStandaloneCreationOutcomeUnknown(error)) {
+        throw error;
+      }
+      const recovery = await this.recoverStandaloneCreation(sessionId);
+      throw new DaemonStandaloneCreationOutcomeUnknownError(
+        sessionId,
+        recovery,
+        error
+      );
+    }
+  }
+  async listStandaloneSessions(options = {}) {
+    return (await this.listStandaloneSessionsPage(options)).sessions;
+  }
+  async listStandaloneSessionsPage(options = {}) {
+    const query = new URLSearchParams();
+    if (options.cursor !== void 0) query.set("cursor", options.cursor);
+    if (options.pageSize !== void 0) {
+      query.set("size", String(options.pageSize));
+    }
+    if (options.archiveState !== void 0) {
+      query.set("archiveState", options.archiveState);
+    }
+    const queryString = query.toString();
+    const suffix = queryString ? `?${queryString}` : "";
+    return await this.standaloneJsonRequest(
+      `/standalone/sessions${suffix}`,
+      "GET /standalone/sessions",
+      parseStandaloneListPage
+    );
+  }
+  async getStandaloneSession(sessionId) {
+    await this.requireCapability(STANDALONE_SESSIONS_CAPABILITY);
+    return await this.getStandaloneSessionUnchecked(sessionId.toLowerCase());
+  }
+  async loadStandaloneSession(sessionId, request = {}, clientId) {
+    return await this.restoreStandaloneSession(
+      "load",
+      sessionId,
+      request,
+      clientId
+    );
+  }
+  async resumeStandaloneSession(sessionId, request = {}, clientId) {
+    return await this.restoreStandaloneSession(
+      "resume",
+      sessionId,
+      request,
+      clientId
+    );
+  }
+  async repairStandaloneSessionDirectory(sessionId) {
+    const normalized = sessionId.toLowerCase();
+    const route = "POST /standalone/sessions/:id/repair-directory";
+    return await this.standaloneJsonRequest(
+      `/standalone/sessions/${urlEncode(normalized)}/repair-directory`,
+      route,
+      (response) => parseStandaloneDirectoryResult(response, route, normalized),
+      { method: "POST", body: {} }
+    );
+  }
+  async renameStandaloneSession(sessionId, displayName, clientId) {
+    const normalized = sessionId.toLowerCase();
+    const route = "PATCH /standalone/sessions/:id/metadata";
+    return await this.standaloneJsonRequest(
+      `/standalone/sessions/${urlEncode(normalized)}/metadata`,
+      route,
+      (response) => parseStandaloneMetadataResult(response, route, normalized),
+      {
+        method: "PATCH",
+        body: { displayName },
+        clientId
+      }
+    );
+  }
+  async exportStandaloneSession(sessionId, options = {}) {
+    await this.requireCapability(STANDALONE_SESSIONS_CAPABILITY);
+    return await this.sessionExportRequest(
+      `/standalone/sessions/${urlEncode(sessionId.toLowerCase())}/export`,
+      "GET /standalone/sessions/:id/export",
+      options
+    );
+  }
+  async archiveStandaloneSessions(sessionIds) {
+    return await this.standaloneBatchRequest(
+      "archive",
+      sessionIds,
+      parseArchiveStandaloneSessionsResult
+    );
+  }
+  async unarchiveStandaloneSessions(sessionIds) {
+    return await this.standaloneBatchRequest(
+      "unarchive",
+      sessionIds,
+      parseUnarchiveStandaloneSessionsResult
+    );
+  }
+  async deleteStandaloneSessions(sessionIds) {
+    return await this.standaloneBatchRequest(
+      "delete",
+      sessionIds,
+      parseDeleteStandaloneSessionsResult
+    );
+  }
+  async standaloneJsonRequest(path, route, parse, options = {}) {
+    await this.requireCapability(STANDALONE_SESSIONS_CAPABILITY);
+    const response = await this.jsonRequest(path, route, {
+      ...options,
+      mode: "rest"
+    });
+    return parse(response, route);
+  }
+  async standaloneBatchRequest(action, sessionIds, parse) {
+    const route = `POST /standalone/sessions/${action}`;
+    return await this.standaloneJsonRequest(
+      `/standalone/sessions/${action}`,
+      route,
+      parse,
+      {
+        method: "POST",
+        body: {
+          sessionIds: sessionIds.map((sessionId) => sessionId.toLowerCase())
+        }
+      }
+    );
+  }
+  async restoreStandaloneSession(action, sessionId, request, clientId) {
+    const normalized = sessionId.toLowerCase();
+    const route = `POST /standalone/sessions/:id/${action}`;
+    const { timeoutMs, ...body } = request;
+    return await this.standaloneJsonRequest(
+      `/standalone/sessions/${urlEncode(normalized)}/${action}`,
+      route,
+      (response) => parseRestoredStandaloneSession(response, route, normalized),
+      {
+        method: "POST",
+        body,
+        clientId,
+        timeoutMs: this.resolveRestoreTimeoutMs(timeoutMs)
+      }
+    );
+  }
+  async getStandaloneSessionUnchecked(sessionId) {
+    const route = "GET /standalone/sessions/:id";
+    const response = await this.jsonRequest(
+      `/standalone/sessions/${urlEncode(sessionId)}`,
+      route,
+      { mode: "rest" }
+    );
+    return parseStandaloneLookup(response, route, sessionId);
+  }
+  async recoverStandaloneCreation(sessionId) {
+    try {
+      const lookup = await this.getStandaloneSessionUnchecked(sessionId);
+      return "state" in lookup ? { state: "creating", sessionId } : { state: "existing", session: lookup };
+    } catch (error) {
+      return isStandaloneSessionNotFoundError(error) ? { state: "absent", sessionId } : { state: "unknown", sessionId, error };
+    }
+  }
   async createOrAttachSession(req, clientId) {
     if (req.sessionId !== void 0 && req.sessionId !== null) {
       await this.requireCapability("session_id_override");
@@ -2446,6 +2898,18 @@ var DaemonClient = class {
       }
     );
   }
+  async sessionWorkflowTasks(sessionId, clientId) {
+    return await this.fetchWithTimeout(
+      `${this.baseUrl}/session/${urlEncode(sessionId)}/tasks?includeWorkflows=true`,
+      { headers: this.headers({}, clientId) },
+      async (res) => {
+        if (!res.ok) {
+          throw await this.failOnError(res, "GET /session/:id/tasks");
+        }
+        return await res.json();
+      }
+    );
+  }
   async sessionLspStatus(sessionId, clientId) {
     return await this.fetchWithTimeout(
       `${this.baseUrl}/session/${urlEncode(sessionId)}/lsp`,
@@ -2459,18 +2923,30 @@ var DaemonClient = class {
     );
   }
   async sessionTaskCancel(sessionId, taskId, kind, clientId) {
+    return await this.sessionTaskMutation(
+      sessionId,
+      taskId,
+      "cancel",
+      { kind },
+      clientId
+    );
+  }
+  async sessionWorkflowTaskAction(sessionId, taskId, action, clientId) {
+    return await this.sessionTaskMutation(sessionId, taskId, "workflow-action", { action }, clientId);
+  }
+  async sessionTaskMutation(sessionId, taskId, route, body, clientId) {
     return await this.fetchWithTimeout(
-      `${this.baseUrl}/session/${urlEncode(sessionId)}/tasks/${urlEncode(taskId)}/cancel`,
+      `${this.baseUrl}/session/${urlEncode(sessionId)}/tasks/${urlEncode(taskId)}/${route}`,
       {
         method: "POST",
         headers: this.headers({ "Content-Type": "application/json" }, clientId),
-        body: JSON.stringify({ kind })
+        body: JSON.stringify(body)
       },
       async (res) => {
         if (!res.ok) {
           throw await this.failOnError(
             res,
-            "POST /session/:id/tasks/:taskId/cancel"
+            `POST /session/:id/tasks/:taskId/${route}`
           );
         }
         return await res.json();
@@ -2518,6 +2994,19 @@ var DaemonClient = class {
    * differs in the URL suffix and the route name reported on errors.
    */
   async restoreSession(action, sessionId, req, clientId) {
+    let sourceType = req.sourceType;
+    let sourceId = req.sourceId;
+    if (req.sourceType !== void 0 || req.sourceId !== void 0) {
+      try {
+        await this.requireCapability("session_source_metadata");
+      } catch (error) {
+        if (!(error instanceof DaemonCapabilityMissingError)) {
+          throw error;
+        }
+        sourceType = void 0;
+        sourceId = void 0;
+      }
+    }
     const timeoutMs = this.resolveRestoreTimeoutMs(req.timeoutMs);
     return await this.fetchWithTimeout(
       `${this.baseUrl}/session/${urlEncode(sessionId)}/${action}`,
@@ -2528,7 +3017,9 @@ var DaemonClient = class {
           cwd: req.workspaceCwd,
           ...req.approvalMode !== void 0 ? { approvalMode: req.approvalMode } : {},
           ...action === "load" && req.historyPageSize !== void 0 ? { historyPageSize: req.historyPageSize } : {},
-          ...action === "load" && req.liveReplayMode !== void 0 ? { liveReplayMode: req.liveReplayMode } : {}
+          ...action === "load" && req.liveReplayMode !== void 0 ? { liveReplayMode: req.liveReplayMode } : {},
+          ...sourceType !== void 0 ? { sourceType } : {},
+          ...sourceId !== void 0 ? { sourceId } : {}
         })
       },
       async (res) => {
@@ -2637,7 +3128,7 @@ var DaemonClient = class {
    * Generate a one-sentence "where did I leave off"
    * recap of the session. Wraps `generateSessionRecap` (core/services/
    * sessionRecap.ts) via an ACP control-channel ext-method, so the
-   * summary is computed against the active GeminiClient chat history
+   * summary is computed against the active LlmClient chat history
    * inside the daemon's ACP child.
    *
    * Non-strict mutation gate — posture matches `/session/:id/prompt`
@@ -2894,8 +3385,9 @@ var DaemonClient = class {
   }
   /**
    * Execute a direct daemon-side shell command for a session. The daemon must
-   * be started with direct session shell enabled and bearer auth configured;
-   * callers must also provide a client id already bound to this session.
+   * be started with direct session shell enabled and either bearer auth or
+   * trusted-loopback operator authority; callers must also provide a client id
+   * already bound to this session.
    * Prefer `DaemonSessionClient.shellCommand()` when available because it
    * forwards the session-bound client id automatically.
    */
@@ -2917,9 +3409,9 @@ var DaemonClient = class {
   }
   /**
    * Toggle a tool name in the workspace's
-   * `tools.disabled` settings list. Strict-gated mutation route — the
-   * daemon must be configured with a bearer token. The daemon writes
-   * the settings file directly and fan-outs a `tool_toggled` event to
+   * `tools.disabled` settings list. The strict mutation gate accepts
+   * trusted-loopback operator authority or listener credentials. The daemon
+   * writes the settings file directly and fan-outs a `tool_toggled` event to
    * every live session SSE bus.
    *
    * Already-registered tools in active sessions are NOT retroactively
@@ -2953,11 +3445,12 @@ var DaemonClient = class {
     );
   }
   /**
-   * Toggle a user-invocable skill in workspace `skills.disabled` settings.
+   * Update workspace Skill settings by name without requiring a loaded Skill.
    * 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.
+   * Pre-flight
+   * `caps.features.includes('workspace_skill_settings_toggle')` before calling.
    */
   async setWorkspaceSkillEnabled(skillName, enabled, opts) {
     return await this.fetchWithTimeout(
@@ -2982,10 +3475,11 @@ var DaemonClient = class {
     );
   }
   /**
-   * Toggle up to 100 user-invocable skills and return every target outcome.
+   * Update workspace Skill settings for up to 100 names in one write.
    *
    * Pre-flight
-   * `caps.features.includes('workspace_skill_batch_toggle')` before calling.
+   * `caps.features.includes('workspace_skill_settings_batch_toggle')` before
+   * calling.
    */
   async setWorkspaceSkillsEnabled(skillNames, enabled, opts) {
     return await this.fetchWithTimeout(
@@ -3074,7 +3568,8 @@ var DaemonClient = class {
           throw await this.failOnError(res, "DELETE /workspace/models");
         }
         return await res.json();
-      }
+      },
+      this.hasExplicitFetchTimeout ? void 0 : DEFAULT_PROVIDER_MUTATION_TIMEOUT_MS
     );
   }
   async workspaceVoice(clientId) {
@@ -4175,7 +4670,8 @@ var DaemonClient = class {
           throw await this.failOnError(res, "POST /workspace/auth/provider");
         }
         return await res.json();
-      }
+      },
+      this.hasExplicitFetchTimeout ? void 0 : DEFAULT_PROVIDER_MUTATION_TIMEOUT_MS
     );
   }
   async addWorkspace(cwd, options = {}) {
@@ -4303,6 +4799,26 @@ var WorkspaceDaemonClient = class {
   workspaceMcp() {
     return this.get("/mcp", "GET /workspaces/:workspace/mcp");
   }
+  ensureRuntime() {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      "/runtime/ensure",
+      "POST /workspaces/:workspace/runtime/ensure",
+      {
+        method: "POST",
+        timeoutMs: WORKSPACE_RUNTIME_ENSURE_TIMEOUT_MS,
+        mode: "rest"
+      }
+    );
+  }
+  runtimeStatus() {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      "/runtime/status",
+      "GET /workspaces/:workspace/runtime/status",
+      { mode: "rest" }
+    );
+  }
   /**
    * Send text directly through this exact workspace's channel worker.
    * A successful capability pre-flight does not guarantee worker liveness;
@@ -5058,6 +5574,22 @@ var WorkspaceDaemonClient = class {
       { mode: "rest" }
     );
   }
+  extensionState(extensionId) {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      `/extensions/${urlEncode(extensionId)}/state`,
+      "GET /workspaces/:workspace/extensions/:extensionId/state",
+      { mode: "rest" }
+    );
+  }
+  setExtensionState(extensionId, update, clientId) {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      `/extensions/${urlEncode(extensionId)}/state`,
+      "PUT /workspaces/:workspace/extensions/:extensionId/state",
+      { method: "PUT", body: update, clientId, mode: "rest" }
+    );
+  }
   setExtensionActivation(extensionId, state, clientId) {
     return this.client.workspaceJsonRequest(
       this.workspaceSelector,
@@ -5191,12 +5723,50 @@ function isSessionAttachmentReference(value) {
 __name(isSessionAttachmentReference, "isSessionAttachmentReference");
 var MAX_ATTACHMENT_CACHE_BYTES = 32 * 1024 * 1024;
 var MAX_ATTACHMENT_CACHE_ENTRIES = 128;
+function createStandaloneRestoredClient(client, restored, includeReplay) {
+  const {
+    state,
+    hasActivePrompt,
+    compactedReplay,
+    liveJournal,
+    historyHasMore,
+    historyAnchorRecordId,
+    replayDegraded,
+    partial,
+    replayError,
+    lastEventId,
+    eventEpoch,
+    ...session
+  } = restored;
+  return new DaemonSessionClient({
+    client,
+    session,
+    hasActivePrompt,
+    state,
+    lastEventId: lastEventId ?? 0,
+    eventEpoch,
+    ...includeReplay ? {
+      replaySnapshot: {
+        compactedReplay: compactedReplay ?? [],
+        liveJournal: liveJournal ?? []
+      },
+      replaySnapshotComplete: Array.isArray(compactedReplay) && Array.isArray(liveJournal),
+      replayPartial: partial === true,
+      replayError,
+      historyHasMore,
+      historyAnchorRecordId,
+      replayDegraded
+    } : {}
+  });
+}
+__name(createStandaloneRestoredClient, "createStandaloneRestoredClient");
 var DaemonSessionClient = class _DaemonSessionClient {
   static {
     __name(this, "DaemonSessionClient");
   }
   client;
   session;
+  restoreStrategy;
   state;
   /**
    * Not `readonly`: {@link consumeReplaySnapshot} swaps it for an empty
@@ -5244,6 +5814,8 @@ var DaemonSessionClient = class _DaemonSessionClient {
   constructor(opts) {
     this.client = opts.client;
     this.session = { ...opts.session };
+    const context = opts.session.context;
+    this.restoreStrategy = opts.session.sourceType === "standalone" && context?.kind === "standalone" ? { kind: "standalone" } : { kind: "workspace", workspaceCwd: opts.session.workspaceCwd };
     this.state = { ...opts.state ?? {} };
     this.hasActivePrompt = opts.hasActivePrompt ?? false;
     this.historyHasMore = opts.historyHasMore ?? false;
@@ -5343,6 +5915,34 @@ var DaemonSessionClient = class _DaemonSessionClient {
       eventEpoch
     });
   }
+  static async createStandalone(client, options = {}) {
+    const session = await client.createStandaloneSession(options);
+    return new _DaemonSessionClient({
+      client,
+      session,
+      hasActivePrompt: session.hasActivePrompt,
+      lastEventId: 0,
+      eventEpoch: session.eventEpoch
+    });
+  }
+  static async loadStandalone(client, sessionId, request = {}, clientId) {
+    const restored = await client.loadStandaloneSession(
+      sessionId,
+      request,
+      clientId
+    );
+    const result = createStandaloneRestoredClient(client, restored, true);
+    await result.hydrateReplaySnapshot();
+    return result;
+  }
+  static async resumeStandalone(client, sessionId, request = {}, clientId) {
+    const restored = await client.resumeStandaloneSession(
+      sessionId,
+      request,
+      clientId
+    );
+    return createStandaloneRestoredClient(client, restored, false);
+  }
   get sessionId() {
     return this.session.sessionId;
   }
@@ -5526,7 +6126,10 @@ var DaemonSessionClient = class _DaemonSessionClient {
    */
   async reattach() {
     if (this.reattaching) return this.reattaching;
-    this.reattaching = this.client.resumeSession(this.sessionId, { workspaceCwd: this.workspaceCwd }).then((session) => {
+    const resume = this.restoreStrategy.kind === "standalone" ? this.client.resumeStandaloneSession(this.sessionId) : this.client.resumeSession(this.sessionId, {
+      workspaceCwd: this.restoreStrategy.workspaceCwd
+    });
+    this.reattaching = resume.then((session) => {
       this.session.clientId = session.clientId;
     });
     try {
@@ -5699,9 +6302,9 @@ var DaemonSessionClient = class _DaemonSessionClient {
   }
   /**
    * Execute a direct daemon-side shell command for this session. Requires the
-   * daemon to opt in to direct session shell and bearer auth; this wrapper
-   * automatically forwards the client id bound when the session was created
-   * or attached.
+   * daemon to opt in to direct session shell with bearer auth or
+   * trusted-loopback authority; this wrapper automatically forwards the client
+   * id bound when the session was created or attached.
    */
   shellCommand(command, signal) {
     return this.client.shellCommand(this.sessionId, command, {
@@ -5724,6 +6327,9 @@ var DaemonSessionClient = class _DaemonSessionClient {
   tasks() {
     return this.client.sessionTasks(this.sessionId, this.clientId);
   }
+  workflowTasks() {
+    return this.client.sessionWorkflowTasks(this.sessionId, this.clientId);
+  }
   lspStatus() {
     return this.client.sessionLspStatus(this.sessionId, this.clientId);
   }
@@ -5735,6 +6341,14 @@ var DaemonSessionClient = class _DaemonSessionClient {
       this.clientId
     );
   }
+  controlWorkflowTask(taskId, action) {
+    return this.client.sessionWorkflowTaskAction(
+      this.sessionId,
+      taskId,
+      action,
+      this.clientId
+    );
+  }
   clearGoal() {
     return this.client.sessionGoalClear(this.sessionId, this.clientId);
   }
@@ -8987,11 +9601,12 @@ function createDaemonToolPreview(input, opts = {}, depth = 0) {
   if (isRecord2(input)) {
     const nestedInput = input["rawInput"] ?? input["input"] ?? input["args"];
     if (nestedInput !== void 0 && nestedInput !== input) {
+      const meta = isRecord2(input["_meta"]) ? input["_meta"] : void 0;
       const nested = createDaemonToolPreview(
         nestedInput,
         {
           title: opts.title ?? getFirstString(input, ["title"]),
-          toolName: opts.toolName ?? getFirstString(input, ["toolName", "name"]),
+          toolName: opts.toolName ?? getFirstString(input, ["toolName", "name"]) ?? (meta ? getFirstString(meta, ["toolName"]) : void 0),
           toolKind: opts.toolKind ?? getFirstString(input, ["kind"])
         },
         depth + 1
@@ -9052,12 +9667,14 @@ function detectFileDiff(input, opts = {}) {
   const oldText = getFirstString(input, [
     "oldText",
     "old_text",
+    "old_string",
     "old_str",
     "oldString"
   ]);
   const explicitNewText = getFirstString(input, [
     "newText",
     "new_text",
+    "new_string",
     "new_str",
     "newString"
   ]);
@@ -10113,6 +10730,10 @@ function discardToolBlock(state, toolCallId) {
   }
 }
 __name(discardToolBlock, "discardToolBlock");
+function isTaskExecutionMode(value) {
+  return value === "foreground" || value === "background";
+}
+__name(isTaskExecutionMode, "isTaskExecutionMode");
 function compactTaskExecutionOutput(rawOutput, retainSubagentBlocks) {
   if (retainSubagentBlocks || !isRecord2(rawOutput) || rawOutput["type"] !== "task_execution") {
     return rawOutput;
@@ -10123,6 +10744,7 @@ function compactTaskExecutionOutput(rawOutput, retainSubagentBlocks) {
     "subagentColor",
     "taskDescription",
     "status",
+    "executionMode",
     "terminateReason",
     "tokenCount",
     "executionSummary"
@@ -12333,12 +12955,15 @@ export {
   DaemonPendingPromptLimitError,
   DaemonSessionClient,
   DaemonSessionIdProtocolError,
+  DaemonStandaloneCreationOutcomeUnknownError,
+  DaemonStandaloneProtocolError,
   DaemonTransportClosedError,
   EXTENSION_ARCHIVE_UPLOAD_TIMEOUT_MS,
   MID_TURN_MESSAGE_INJECTED_EVENT,
   PENDING_PROMPT_ADDED_EVENT,
   PENDING_PROMPT_COMPLETED_EVENT,
   PENDING_PROMPT_STARTED_EVENT,
+  STANDALONE_SESSIONS_CAPABILITY,
   SseFramingError,
   UNRECOGNIZED_DIAGNOSTICS_LIMIT,
   WorkspaceDaemonClient,
@@ -12368,8 +12993,11 @@ export {
   isNonBlockingAccepted,
   isSessionLevelNotFound,
   isStaleBranchPointError,
+  isStandaloneCreationOutcomeUnknown,
+  isStandaloneSessionNotFoundError,
   isSubagentChildBlock,
   isSubagentSessionNotFound,
+  isTaskExecutionMode,
   isTrimmedPermissionBlockId,
   isTrimmedToolBlockId,
   isUnrecognizedDiagnosticReason,
@@ -12410,3 +13038,8 @@ export {
  * Copyright 2025 Alibaba Group Holding Limited. All Rights Reserved.
  * Licensed under the Apache License, Version 2.0
  */
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */