@qwen-code/qwen-code 0.22.0 → 0.22.2-nightly.20260828.7357136dd1

package/chunks/{daemon-RZZUPGOJ.js → daemon-K5XS42ID.js}

@@ -181,7 +181,7 @@ 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");
 
@@ -556,6 +556,18 @@ __name(composeAbortSignals, "composeAbortSignals");
 
 // packages/sdk-typescript/src/daemon/types.ts
 init_esbuild_shims();
+
+// packages/sdk-typescript/src/types/permission-mode.ts
+init_esbuild_shims();
+var PERMISSION_MODES = [
+  "plan",
+  "default",
+  "auto-edit",
+  "auto",
+  "yolo"
+];
+
+// packages/sdk-typescript/src/daemon/types.ts
 var DaemonCapabilityMissingError = class extends Error {
   static {
     __name(this, "DaemonCapabilityMissingError");
@@ -610,13 +622,233 @@ function isDaemonContentHash(value) {
   return typeof value === "string" && DAEMON_CONTENT_HASH_RE.test(value);
 }
 __name(isDaemonContentHash, "isDaemonContentHash");
-var DAEMON_APPROVAL_MODES = [
-  "plan",
-  "default",
-  "auto-edit",
-  "auto",
-  "yolo"
-];
+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";
@@ -1569,16 +1801,15 @@ var DaemonClient = class {
     );
   }
   async readWorkspaceFileBytes(filePath, opts = {}, clientId) {
-    const url = new URL(`${this.baseUrl}/file/bytes`);
-    url.searchParams.set("path", filePath);
+    const query = new URLSearchParams({ path: filePath });
     if (opts.offset !== void 0) {
-      url.searchParams.set("offset", String(opts.offset));
+      query.set("offset", String(opts.offset));
     }
     if (opts.maxBytes !== void 0) {
-      url.searchParams.set("maxBytes", String(opts.maxBytes));
+      query.set("maxBytes", String(opts.maxBytes));
     }
     return await this.fetchWithTimeout(
-      url.toString(),
+      `${this.baseUrl}/file/bytes?${query.toString()}`,
       { headers: this.headers({}, clientId) },
       async (res) => {
         if (!res.ok) throw await this.failOnError(res, "GET /file/bytes");
@@ -2137,6 +2368,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");
@@ -4014,13 +4424,20 @@ var DaemonClient = class {
       }
     );
   }
-  async archiveSessionsData(sessionIds, clientId) {
+  async archiveSessionsData(sessionIds, clientIdOrOptions, clientId) {
+    const options = typeof clientIdOrOptions === "object" ? clientIdOrOptions : void 0;
     return await this.fetchWithTimeout(
       `${this.baseUrl}/sessions/archive`,
       {
         method: "POST",
-        headers: this.headers({ "Content-Type": "application/json" }, clientId),
-        body: JSON.stringify({ sessionIds })
+        headers: this.headers(
+          { "Content-Type": "application/json" },
+          typeof clientIdOrOptions === "string" ? clientIdOrOptions : clientId
+        ),
+        body: JSON.stringify({
+          sessionIds,
+          ...options?.resolveConflicts !== void 0 ? { resolveConflicts: options.resolveConflicts } : {}
+        })
       },
       async (res) => {
         if (res.ok) {
@@ -4030,13 +4447,20 @@ var DaemonClient = class {
       }
     );
   }
-  async unarchiveSessionsData(sessionIds, clientId) {
+  async unarchiveSessionsData(sessionIds, clientIdOrOptions, clientId) {
+    const options = typeof clientIdOrOptions === "object" ? clientIdOrOptions : void 0;
     return await this.fetchWithTimeout(
       `${this.baseUrl}/sessions/unarchive`,
       {
         method: "POST",
-        headers: this.headers({ "Content-Type": "application/json" }, clientId),
-        body: JSON.stringify({ sessionIds })
+        headers: this.headers(
+          { "Content-Type": "application/json" },
+          typeof clientIdOrOptions === "string" ? clientIdOrOptions : clientId
+        ),
+        body: JSON.stringify({
+          sessionIds,
+          ...options?.resolveConflicts !== void 0 ? { resolveConflicts: options.resolveConflicts } : {}
+        })
       },
       async (res) => {
         if (res.ok) {
@@ -4832,20 +5256,28 @@ var WorkspaceDaemonClient = class {
       clientId
     );
   }
-  archiveSessionsData(sessionIds, clientId) {
+  archiveSessionsData(sessionIds, clientIdOrOptions, clientId) {
+    const options = typeof clientIdOrOptions === "object" ? clientIdOrOptions : void 0;
     return this.post(
       "/sessions/archive",
       "POST /workspaces/:workspace/sessions/archive",
-      { sessionIds },
-      clientId
+      {
+        sessionIds,
+        ...options?.resolveConflicts !== void 0 ? { resolveConflicts: options.resolveConflicts } : {}
+      },
+      typeof clientIdOrOptions === "string" ? clientIdOrOptions : clientId
     );
   }
-  unarchiveSessionsData(sessionIds, clientId) {
+  unarchiveSessionsData(sessionIds, clientIdOrOptions, clientId) {
+    const options = typeof clientIdOrOptions === "object" ? clientIdOrOptions : void 0;
     return this.post(
       "/sessions/unarchive",
       "POST /workspaces/:workspace/sessions/unarchive",
-      { sessionIds },
-      clientId
+      {
+        sessionIds,
+        ...options?.resolveConflicts !== void 0 ? { resolveConflicts: options.resolveConflicts } : {}
+      },
+      typeof clientIdOrOptions === "string" ? clientIdOrOptions : clientId
     );
   }
   readWorkspaceFile(filePath, opts = {}, clientId) {
@@ -5164,12 +5596,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
@@ -5217,6 +5687,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;
@@ -5316,6 +5788,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;
   }
@@ -5499,7 +5999,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 {
@@ -9723,7 +10226,9 @@ function clearActiveAssistant(state, event) {
 }
 __name(clearActiveAssistant, "clearActiveAssistant");
 function applyAssistantUsage(state, event) {
-  const block = getWritableBlockById(state, state.activeAssistantBlockId);
+  if (isLegacySubagentUsageDuplicate(state, event)) return;
+  const activeBlockId = state.activeAssistantBlockId ?? (event.parentToolCallId ? void 0 : latestTopLevelAssistantBlockIdInCurrentTurn(state));
+  const block = getWritableBlockById(state, activeBlockId);
   if (!block || block.kind !== "assistant") return;
   const prev = block.usage;
   block.usage = {
@@ -9734,6 +10239,31 @@ function applyAssistantUsage(state, event) {
   block.updatedAt = state.now;
 }
 __name(applyAssistantUsage, "applyAssistantUsage");
+function isLegacySubagentUsageDuplicate(state, event) {
+  if (event.parentToolCallId || !event.sourceRecordIds?.length) return false;
+  const sourceRecordIds = new Set(event.sourceRecordIds);
+  for (let i = state.blocks.length - 1; i >= 0; i -= 1) {
+    const block = state.blocks[i];
+    if (block.kind === "user" && !block.parentToolCallId) return false;
+    if (block.kind !== "tool" || !block.sourceRecordIds?.some((id) => sourceRecordIds.has(id))) {
+      continue;
+    }
+    const rawOutput = isRecord2(block.rawOutput) ? block.rawOutput : void 0;
+    const summary = rawOutput && isRecord2(rawOutput["executionSummary"]) ? rawOutput["executionSummary"] : void 0;
+    return summary?.["inputTokens"] === event.usage.inputTokens && summary["outputTokens"] === event.usage.outputTokens && (summary["cachedTokens"] ?? 0) === (event.usage.cachedTokens ?? 0);
+  }
+  return false;
+}
+__name(isLegacySubagentUsageDuplicate, "isLegacySubagentUsageDuplicate");
+function latestTopLevelAssistantBlockIdInCurrentTurn(state) {
+  for (let i = state.blocks.length - 1; i >= 0; i -= 1) {
+    const block = state.blocks[i];
+    if (block.kind === "user" && !block.parentToolCallId) return void 0;
+    if (block.kind === "assistant" && !block.parentToolCallId) return block.id;
+  }
+  return void 0;
+}
+__name(latestTopLevelAssistantBlockIdInCurrentTurn, "latestTopLevelAssistantBlockIdInCurrentTurn");
 function applySubagentUsageToParentTool(state, event) {
   if (!event.parentToolCallId) return;
   const block = getWritableBlockById(
@@ -12279,12 +12809,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,
@@ -12314,6 +12847,8 @@ export {
   isNonBlockingAccepted,
   isSessionLevelNotFound,
   isStaleBranchPointError,
+  isStandaloneCreationOutcomeUnknown,
+  isStandaloneSessionNotFoundError,
   isSubagentChildBlock,
   isSubagentSessionNotFound,
   isTrimmedPermissionBlockId,
@@ -12356,3 +12891,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
+ */