@qwen-code/qwen-code 0.22.2-preview.1 → 0.22.3

package/chunks/{cron-delete-4N5BI6GL.js → cron-delete-MBLQCAYY.js}

@@ -3,18 +3,18 @@
 import {
   CRON_TASKS_DISPLAY_PATH,
   removeCronTasks
-} from "./chunk-JECO75XD.js";
+} from "./chunk-D5LUXLUH.js";
 import "./chunk-VGC4I5JJ.js";
-import "./chunk-7QGEJI7M.js";
+import "./chunk-23RFD54N.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-KOJ6MHD5.js";
+} from "./chunk-UTLCH2FK.js";
 import {
   getErrorMessage
-} from "./chunk-2NNTE2ED.js";
+} from "./chunk-UHQFIS7N.js";
 import "./chunk-TBWQLLFO.js";
 import {
   init_esbuild_shims

package/chunks/{cron-list-2CATIPUX.js → cron-list-DWH2PQ47.js}

@@ -7,16 +7,16 @@ import {
   CRON_TASKS_DISPLAY_PATH,
   readCronTasks,
   taskHasLegacyCondition
-} from "./chunk-JECO75XD.js";
+} from "./chunk-D5LUXLUH.js";
 import "./chunk-VGC4I5JJ.js";
-import "./chunk-7QGEJI7M.js";
+import "./chunk-23RFD54N.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-KOJ6MHD5.js";
-import "./chunk-2NNTE2ED.js";
+} from "./chunk-UTLCH2FK.js";
+import "./chunk-UHQFIS7N.js";
 import "./chunk-TBWQLLFO.js";
 import {
   init_esbuild_shims

package/chunks/{daemon-NAYK4XXU.js → daemon-3GNHB3M2.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");
 
@@ -624,6 +624,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";
@@ -2142,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");
@@ -2637,7 +3042,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`
@@ -2953,11 +3358,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 +3388,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(
@@ -5191,12 +5598,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 +5689,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 +5790,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 +6001,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 {
@@ -9750,7 +10228,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 = {
@@ -9761,6 +10241,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(
@@ -12306,12 +12811,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,
@@ -12341,6 +12849,8 @@ export {
   isNonBlockingAccepted,
   isSessionLevelNotFound,
   isStaleBranchPointError,
+  isStandaloneCreationOutcomeUnknown,
+  isStandaloneSessionNotFoundError,
   isSubagentChildBlock,
   isSubagentSessionNotFound,
   isTrimmedPermissionBlockId,
@@ -12383,3 +12893,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
+ */