@qwen-code/qwen-code 0.21.0 → 0.21.1-nightly.20260731.702932cc7

package/chunks/channel-management-service-5S7YCWX5.js

@@ -0,0 +1,418 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  resolveChannelCwd
+} from "./chunk-FANRZEAJ.js";
+import {
+  getPlugin
+} from "./chunk-KWHKHSIS.js";
+import {
+  canonicalizeWorkspace
+} from "./chunk-2RFKHEXL.js";
+import {
+  normalizeWorkerDiagnostic
+} from "./chunk-6MPDY6ZG.js";
+import {
+  isAllChannelSelectionName
+} from "./chunk-ALMR3E6Q.js";
+import {
+  redactLogCredentials
+} from "./chunk-M5GB774H.js";
+import {
+  PairingStore,
+  sanitizeLogText
+} from "./chunk-JCJ7LKNA.js";
+import "./chunk-UDXSXLER.js";
+import "./chunk-TWPJO254.js";
+import "./chunk-H6XPXXMH.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/serve/channel-management-service.ts
+init_esbuild_shims();
+var ChannelManagementError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ChannelManagementError";
+  }
+  static {
+    __name(this, "ChannelManagementError");
+  }
+};
+function diagnostic(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return sanitizeLogText(
+    redactLogCredentials(normalizeWorkerDiagnostic(message)),
+    512
+  );
+}
+__name(diagnostic, "diagnostic");
+function usesEnvironment(value) {
+  return typeof value === "string" && /^\$[A-Za-z_][A-Za-z0-9_]*$/.test(value);
+}
+__name(usesEnvironment, "usesEnvironment");
+function createChannelManagementService(opts) {
+  const diagnostics = /* @__PURE__ */ new Map();
+  let mutationTail = Promise.resolve();
+  const inMutationLane = /* @__PURE__ */ __name((mutation) => {
+    const result = mutationTail.then(mutation, mutation);
+    mutationTail = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  }, "inMutationLane");
+  const assertExpectedRevision = /* @__PURE__ */ __name((snapshot, expectedRevision) => {
+    if (snapshot.revision !== expectedRevision) {
+      throw new ChannelManagementError(
+        "channel_settings_conflict",
+        "Channel settings changed; reload before trying again."
+      );
+    }
+  }, "assertExpectedRevision");
+  const workerFor = /* @__PURE__ */ __name((name) => {
+    const matches = opts.manager.state().workers.filter(
+      (worker) => worker.adapters?.some((adapter) => adapter.name === name) || worker.requestedChannels?.includes(name) || worker.channels.includes(name)
+    );
+    return matches;
+  }, "workerFor");
+  const workspaceCommittedNames = /* @__PURE__ */ __name(() => opts.manager.committedChannelNames().filter(
+    (name) => workerFor(name).some((w) => w.workspaceCwd === opts.workspaceCwd)
+  ), "workspaceCommittedNames");
+  const assertOwnedRuntime = /* @__PURE__ */ __name((name) => {
+    if (!workspaceCommittedNames().includes(name)) return;
+    const workers = workerFor(name).filter(
+      (worker) => worker.workspaceCwd === opts.workspaceCwd
+    );
+    if (workers.length !== 1) {
+      throw new ChannelManagementError(
+        "channel_runtime_owner_mismatch",
+        `Channel "${name}" does not have one confirmed runtime owner in this workspace.`
+      );
+    }
+  }, "assertOwnedRuntime");
+  const runtimeFor = /* @__PURE__ */ __name((name) => {
+    const retainedError = diagnostics.get(name);
+    if (retainedError) return { state: "error", lastError: retainedError };
+    if (!workspaceCommittedNames().includes(name)) {
+      return { state: "stopped" };
+    }
+    const state = opts.manager.state();
+    const workers = workerFor(name).filter(
+      (worker2) => worker2.workspaceCwd === opts.workspaceCwd
+    );
+    if (workers.length !== 1) {
+      return {
+        state: "error",
+        lastError: "Channel runtime owner is unknown or ambiguous."
+      };
+    }
+    const worker = workers[0];
+    const adapter = worker.adapters?.find((item) => item.name === name);
+    if (adapter?.state === "connected") return { state: "connected" };
+    if (adapter?.state === "error") {
+      return {
+        state: "error",
+        ...adapter.error ? { lastError: diagnostic(adapter.error) } : {}
+      };
+    }
+    if (adapter?.state === "starting" || state.transition === "starting" || state.transition === "reconciling") {
+      return { state: "starting" };
+    }
+    if (worker.state === "running") return { state: "partial" };
+    return {
+      state: "error",
+      ...worker.error ? { lastError: diagnostic(worker.error) } : {}
+    };
+  }, "runtimeFor");
+  const instanceFrom = /* @__PURE__ */ __name(async (name, rawConfig, startupNames) => {
+    const type = typeof rawConfig["type"] === "string" ? rawConfig["type"] : "";
+    const plugin = type ? await getPlugin(type) : void 0;
+    if (!plugin?.management) {
+      return {
+        name,
+        config: type ? { type } : {},
+        secrets: {},
+        startsWithServe: startupNames.some(isAllChannelSelectionName) || startupNames.includes(name),
+        runtime: runtimeFor(name)
+      };
+    }
+    const secretKeys = new Set(
+      plugin.management.fields.filter((field) => field.kind === "secret").map((field) => field.key)
+    );
+    const config = {};
+    const secrets = {};
+    for (const [key, value] of Object.entries(rawConfig)) {
+      if (!secretKeys.has(key)) {
+        config[key] = value;
+        continue;
+      }
+      secrets[key] = {
+        present: value !== void 0,
+        ...value !== void 0 ? { source: usesEnvironment(value) ? "environment" : "literal" } : {}
+      };
+    }
+    for (const key of secretKeys) {
+      secrets[key] ??= { present: false };
+    }
+    return {
+      name,
+      config,
+      secrets,
+      startsWithServe: startupNames.some(isAllChannelSelectionName) || startupNames.includes(name),
+      runtime: runtimeFor(name)
+    };
+  }, "instanceFrom");
+  const listFrom = /* @__PURE__ */ __name(async (persisted) => {
+    const entries = await Promise.all(
+      Object.entries(persisted.channels).map(
+        async ([name, config]) => [
+          name,
+          await instanceFrom(name, config, persisted.startupNames)
+        ]
+      )
+    );
+    return {
+      revision: persisted.revision,
+      instances: Object.fromEntries(entries)
+    };
+  }, "listFrom");
+  const resultFor = /* @__PURE__ */ __name(async (name, persisted = opts.store.snapshot()) => {
+    const snapshot = await listFrom(persisted);
+    const instance = Object.hasOwn(snapshot.instances, name) ? snapshot.instances[name] : {
+      name,
+      config: {},
+      secrets: {},
+      startsWithServe: false,
+      runtime: runtimeFor(name)
+    };
+    return { snapshot, instance };
+  }, "resultFor");
+  const stopChannel = /* @__PURE__ */ __name((name) => opts.manager.setChannelEnabled(
+    { name, workspaceCwd: opts.workspaceCwd },
+    false
+  ), "stopChannel");
+  const assertManageableInstanceName = /* @__PURE__ */ __name((name) => {
+    if (isAllChannelSelectionName(name)) {
+      throw new ChannelManagementError(
+        "invalid_channel_instance_name",
+        'Channel instance name "all" is reserved for startup selection.'
+      );
+    }
+  }, "assertManageableInstanceName");
+  const assertWorkspaceConfig = /* @__PURE__ */ __name((config) => {
+    const rawCwd = config["cwd"];
+    if (typeof rawCwd !== "string") return;
+    const workspaceCwd = canonicalizeWorkspace(opts.workspaceCwd);
+    const channelCwd = canonicalizeWorkspace(
+      resolveChannelCwd(rawCwd, workspaceCwd)
+    );
+    if (channelCwd !== workspaceCwd) {
+      throw new ChannelManagementError(
+        "channel_workspace_mismatch",
+        "Channel workspace must match the selected workspace."
+      );
+    }
+  }, "assertWorkspaceConfig");
+  const pairingStoreFor = /* @__PURE__ */ __name((name) => {
+    assertManageableInstanceName(name);
+    const channels = opts.store.snapshot().channels;
+    if (!Object.hasOwn(channels, name)) {
+      throw new ChannelManagementError(
+        "channel_instance_not_found",
+        `Channel "${name}" is not configured in this workspace.`
+      );
+    }
+    const config = channels[name];
+    assertWorkspaceConfig(config);
+    if (config["senderPolicy"] !== "pairing") {
+      throw new ChannelManagementError(
+        "channel_pairing_not_enabled",
+        `Channel "${name}" does not use pairing mode.`
+      );
+    }
+    return new PairingStore(name, opts.workspaceCwd);
+  }, "pairingStoreFor");
+  const service = {
+    async list() {
+      return listFrom(opts.store.snapshot());
+    },
+    async upsert(name, request) {
+      assertManageableInstanceName(name);
+      assertWorkspaceConfig(request.config);
+      const active = workspaceCommittedNames().includes(name);
+      if (active) assertOwnedRuntime(name);
+      const persisted = await opts.store.upsert(name, request);
+      diagnostics.delete(name);
+      if (active) {
+        try {
+          await opts.manager.reloadWorkspace(opts.workspaceCwd, name);
+        } catch (error) {
+          diagnostics.set(name, diagnostic(error));
+          try {
+            await stopChannel(name);
+          } catch {
+          }
+        }
+      }
+      return resultFor(name, persisted);
+    },
+    async remove(name, request) {
+      assertManageableInstanceName(name);
+      const current = opts.store.snapshot();
+      if (!Object.hasOwn(current.channels, name)) {
+        throw new ChannelManagementError(
+          "channel_instance_not_found",
+          `Channel "${name}" is not configured in this workspace.`
+        );
+      }
+      assertWorkspaceConfig(current.channels[name]);
+      assertExpectedRevision(current, request.expectedRevision);
+      if (workspaceCommittedNames().includes(name)) {
+        assertOwnedRuntime(name);
+        await stopChannel(name);
+      }
+      const persisted = await opts.store.remove(name, request);
+      diagnostics.delete(name);
+      return resultFor(name, persisted);
+    },
+    async setStartup(name, request) {
+      assertManageableInstanceName(name);
+      const current = opts.store.snapshot();
+      if (!Object.hasOwn(current.channels, name)) {
+        throw new ChannelManagementError(
+          "channel_instance_not_found",
+          `Channel "${name}" is not configured in this workspace.`
+        );
+      }
+      assertWorkspaceConfig(current.channels[name]);
+      const startsAll = current.startupNames.some(isAllChannelSelectionName);
+      if (startsAll && request.enabled) {
+        assertExpectedRevision(current, request.expectedRevision);
+        return resultFor(name, current);
+      }
+      const startupNames = startsAll ? Object.keys(current.channels).filter(
+        (item) => !isAllChannelSelectionName(item) && item !== name
+      ) : request.enabled ? current.startupNames.includes(name) ? current.startupNames : [...current.startupNames, name] : current.startupNames.filter((item) => item !== name);
+      const persisted = await opts.store.setStartupNames(startupNames, {
+        expectedRevision: request.expectedRevision
+      });
+      return resultFor(name, persisted);
+    },
+    async start(name) {
+      assertManageableInstanceName(name);
+      const persisted = opts.store.snapshot();
+      if (!Object.hasOwn(persisted.channels, name)) {
+        throw new ChannelManagementError(
+          "channel_instance_not_found",
+          `Channel "${name}" is not configured in this workspace.`
+        );
+      }
+      assertWorkspaceConfig(persisted.channels[name]);
+      await opts.manager.setChannelEnabled(
+        { name, workspaceCwd: opts.workspaceCwd },
+        true
+      );
+      diagnostics.delete(name);
+      return resultFor(name, persisted);
+    },
+    async stop(name) {
+      assertManageableInstanceName(name);
+      const persisted = opts.store.snapshot();
+      if (!Object.hasOwn(persisted.channels, name)) {
+        throw new ChannelManagementError(
+          "channel_instance_not_found",
+          `Channel "${name}" is not configured in this workspace.`
+        );
+      }
+      assertWorkspaceConfig(persisted.channels[name]);
+      await opts.manager.setChannelEnabled(
+        { name, workspaceCwd: opts.workspaceCwd },
+        false
+      );
+      diagnostics.delete(name);
+      return resultFor(name, persisted);
+    },
+    async restart(name) {
+      assertManageableInstanceName(name);
+      const persisted = opts.store.snapshot();
+      if (!Object.hasOwn(persisted.channels, name)) {
+        throw new ChannelManagementError(
+          "channel_instance_not_found",
+          `Channel "${name}" is not configured in this workspace.`
+        );
+      }
+      assertWorkspaceConfig(persisted.channels[name]);
+      if (!workspaceCommittedNames().includes(name)) {
+        throw new ChannelManagementError(
+          "channel_worker_not_enabled",
+          `Channel "${name}" is not running.`
+        );
+      }
+      assertOwnedRuntime(name);
+      try {
+        await opts.manager.reloadWorkspace(opts.workspaceCwd, name);
+        diagnostics.delete(name);
+      } catch (error) {
+        diagnostics.set(name, diagnostic(error));
+        throw error;
+      }
+      return resultFor(name, persisted);
+    },
+    async pairingRequests(name) {
+      return { requests: pairingStoreFor(name).listPending() };
+    },
+    async approvePairing(name, code) {
+      const store = pairingStoreFor(name);
+      const approved = store.approve(code);
+      if (!approved) {
+        throw new ChannelManagementError(
+          "channel_pairing_request_not_found",
+          "Pairing request was not found or has expired."
+        );
+      }
+      return { approved, requests: store.listPending() };
+    },
+    async pairingApprovals(name) {
+      return { senderIds: pairingStoreFor(name).getAllowlist() };
+    },
+    async revokePairingApproval(name, senderId) {
+      const store = pairingStoreFor(name);
+      if (!store.revoke(senderId)) {
+        throw new ChannelManagementError(
+          "channel_pairing_approval_not_found",
+          "Pairing approval was not found."
+        );
+      }
+      return { revoked: senderId, senderIds: store.getAllowlist() };
+    }
+  };
+  return {
+    list: /* @__PURE__ */ __name(() => service.list(), "list"),
+    upsert: /* @__PURE__ */ __name((name, request) => inMutationLane(() => service.upsert(name, request)), "upsert"),
+    remove: /* @__PURE__ */ __name((name, request) => inMutationLane(() => service.remove(name, request)), "remove"),
+    setStartup: /* @__PURE__ */ __name((name, request) => inMutationLane(() => service.setStartup(name, request)), "setStartup"),
+    start: /* @__PURE__ */ __name((name) => inMutationLane(() => service.start(name)), "start"),
+    stop: /* @__PURE__ */ __name((name) => inMutationLane(() => service.stop(name)), "stop"),
+    restart: /* @__PURE__ */ __name((name) => inMutationLane(() => service.restart(name)), "restart"),
+    pairingRequests: /* @__PURE__ */ __name((name) => service.pairingRequests(name), "pairingRequests"),
+    approvePairing: /* @__PURE__ */ __name((name, code) => inMutationLane(() => service.approvePairing(name, code)), "approvePairing"),
+    pairingApprovals: /* @__PURE__ */ __name((name) => service.pairingApprovals(name), "pairingApprovals"),
+    revokePairingApproval: /* @__PURE__ */ __name((name, senderId) => inMutationLane(() => service.revokePairingApproval(name, senderId)), "revokePairingApproval")
+  };
+}
+__name(createChannelManagementService, "createChannelManagementService");
+export {
+  ChannelManagementError,
+  createChannelManagementService
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/channel-settings-store-NLOKYO23.js

@@ -0,0 +1,91 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  ChannelSettingsError,
+  WorkspaceChannelSettingsStore,
+  assertValidChannelSecretUpdates
+} from "./chunk-45UYUCJ6.js";
+import "./chunk-KWHKHSIS.js";
+import "./chunk-A5T5W7PR.js";
+import "./chunk-RKUWKYED.js";
+import "./chunk-GOXKNSDZ.js";
+import "./chunk-IDS7MSUP.js";
+import "./chunk-B3TA3IF5.js";
+import "./chunk-X2E5TFJ5.js";
+import "./chunk-6PEXNQTX.js";
+import "./chunk-UU2B5YG6.js";
+import "./chunk-ALGGS7UH.js";
+import "./chunk-MR3PXB6E.js";
+import "./chunk-OWAK7LMW.js";
+import "./chunk-FRXG4ARO.js";
+import "./chunk-5M6IDOMF.js";
+import "./chunk-TWPJO254.js";
+import "./chunk-H6XPXXMH.js";
+import "./chunk-AOHY3QJ3.js";
+import "./chunk-5NNHICSA.js";
+import "./chunk-SHN4KHDK.js";
+import "./chunk-JXVC2PL3.js";
+import "./chunk-KRXPRVGL.js";
+import "./chunk-6PVPNMXU.js";
+import "./chunk-26JK4RPD.js";
+import "./chunk-IRH27ZC2.js";
+import "./chunk-QHWCP53L.js";
+import "./chunk-TEGJSJDF.js";
+import "./chunk-TIRRPCFS.js";
+import "./chunk-O6GEWCJA.js";
+import "./chunk-T26EAKDL.js";
+import "./chunk-CPBF7KYF.js";
+import "./chunk-4KP2F2TE.js";
+import "./chunk-3APUUXRF.js";
+import "./chunk-THVU3RNH.js";
+import "./chunk-LHKCY7DY.js";
+import "./chunk-6FMJLI5M.js";
+import "./chunk-CBBP4BMC.js";
+import "./chunk-S6LOFUVP.js";
+import "./chunk-K623ENWT.js";
+import "./chunk-AQ37AY7B.js";
+import "./chunk-N4ACHWNH.js";
+import "./chunk-ZPJWUGCS.js";
+import "./chunk-D4HTUMGX.js";
+import "./chunk-NAVJD2PQ.js";
+import "./chunk-LOY7RWQG.js";
+import "./chunk-E6CJ2SMM.js";
+import "./chunk-DGEIYUC3.js";
+import "./chunk-MPHPFVKK.js";
+import "./chunk-GLNBDYUX.js";
+import "./chunk-DJ2GSRLV.js";
+import "./chunk-2YCYFWYZ.js";
+import "./chunk-Z3S5EMOW.js";
+import "./chunk-2J3OJGTL.js";
+import "./chunk-P3QQPMQA.js";
+import "./chunk-XQK4XXTN.js";
+import "./chunk-GLCZKT5V.js";
+import "./chunk-QDK4F2N5.js";
+import "./chunk-NVFSGPIF.js";
+import "./chunk-VGC4I5JJ.js";
+import "./chunk-3I6DUGQD.js";
+import "./chunk-7ULQIS27.js";
+import "./chunk-MM7TH7ZM.js";
+import "./chunk-DKPJUF5F.js";
+import "./chunk-46UV252V.js";
+import "./chunk-ZBVS26BY.js";
+import "./chunk-Q3T5KA2V.js";
+import "./chunk-R2XWGR75.js";
+import "./chunk-HC45LTEN.js";
+import "./chunk-QARJNL2V.js";
+import "./chunk-W4RQUHY3.js";
+import "./chunk-G7XXKQYS.js";
+import "./chunk-E2BHWIDT.js";
+import "./chunk-VOQXFAY5.js";
+import "./chunk-75DOP5OR.js";
+import "./chunk-DMTGGOSA.js";
+import "./chunk-YQ3U5MUC.js";
+import "./chunk-AMDSOFFV.js";
+import "./chunk-QUGAUQGJ.js";
+import "./chunk-5O2XNYP6.js";
+import "./chunk-J2S4EL5Y.js";
+export {
+  ChannelSettingsError,
+  WorkspaceChannelSettingsStore,
+  assertValidChannelSecretUpdates
+};

package/chunks/{channel-worker-group-2ZD7TVAT.js → channel-worker-group-OVWGYMZS.js}

@@ -3,15 +3,20 @@
 import {
   ChannelWorkerReconcileError,
   createChannelWorkerGroup
-} from "./chunk-UDX5OBWR.js";
-import "./chunk-5NBDS5S6.js";
-import "./chunk-LK7CHLVP.js";
-import "./chunk-JLU636DO.js";
+} from "./chunk-E2FN6SM7.js";
+import "./chunk-CPZAH673.js";
+import "./chunk-B4AJNNOL.js";
+import "./chunk-2RFKHEXL.js";
+import "./chunk-FCYYAB4S.js";
+import "./chunk-FYJ7W2PI.js";
+import "./chunk-U4VTUMMK.js";
+import "./chunk-6MPDY6ZG.js";
+import "./chunk-ALMR3E6Q.js";
 import "./chunk-BK2UNYWD.js";
 import "./chunk-M5GB774H.js";
-import "./chunk-RWTEFFPU.js";
-import "./chunk-UDXSXLER.js";
 import "./chunk-5HBA2Z7V.js";
+import "./chunk-JCJ7LKNA.js";
+import "./chunk-UDXSXLER.js";
 import "./chunk-TWPJO254.js";
 import "./chunk-H6XPXXMH.js";
 import "./chunk-5O2XNYP6.js";

package/chunks/{channel-worker-manager-4OA4BCGB.js → channel-worker-manager-H55GKOQA.js}

@@ -2,21 +2,26 @@
 "use strict";
 import {
   ChannelWorkerReconcileError
-} from "./chunk-UDX5OBWR.js";
+} from "./chunk-E2FN6SM7.js";
+import "./chunk-CPZAH673.js";
+import "./chunk-B4AJNNOL.js";
+import "./chunk-2RFKHEXL.js";
 import {
   ChannelWorkerStartupError,
   ChannelWorkerStopError
-} from "./chunk-5NBDS5S6.js";
+} from "./chunk-FCYYAB4S.js";
+import "./chunk-FYJ7W2PI.js";
 import {
   ChannelDeliveryError,
   ChannelWebhookEnqueueError
-} from "./chunk-LK7CHLVP.js";
-import "./chunk-JLU636DO.js";
+} from "./chunk-U4VTUMMK.js";
+import "./chunk-6MPDY6ZG.js";
+import "./chunk-ALMR3E6Q.js";
 import "./chunk-BK2UNYWD.js";
 import "./chunk-M5GB774H.js";
-import "./chunk-RWTEFFPU.js";
-import "./chunk-UDXSXLER.js";
 import "./chunk-5HBA2Z7V.js";
+import "./chunk-JCJ7LKNA.js";
+import "./chunk-UDXSXLER.js";
 import "./chunk-TWPJO254.js";
 import "./chunk-H6XPXXMH.js";
 import {

package/chunks/{channel-worker-supervisor-V7KCFJTS.js → channel-worker-supervisor-CABBXYHK.js}

@@ -4,14 +4,16 @@ import {
   ChannelWorkerStartupError,
   ChannelWorkerStopError,
   createChannelWorkerSupervisor
-} from "./chunk-5NBDS5S6.js";
-import "./chunk-LK7CHLVP.js";
-import "./chunk-JLU636DO.js";
+} from "./chunk-FCYYAB4S.js";
+import "./chunk-FYJ7W2PI.js";
+import "./chunk-U4VTUMMK.js";
+import "./chunk-6MPDY6ZG.js";
+import "./chunk-ALMR3E6Q.js";
 import "./chunk-BK2UNYWD.js";
 import "./chunk-M5GB774H.js";
-import "./chunk-RWTEFFPU.js";
-import "./chunk-UDXSXLER.js";
 import "./chunk-5HBA2Z7V.js";
+import "./chunk-JCJ7LKNA.js";
+import "./chunk-UDXSXLER.js";
 import "./chunk-TWPJO254.js";
 import "./chunk-H6XPXXMH.js";
 import "./chunk-5O2XNYP6.js";

package/chunks/{chunk-RIBKPMRP.js → chunk-23F4XGWO.js}

@@ -2,21 +2,24 @@
 "use strict";
 import {
   HistoryReplayer
-} from "./chunk-EBJQ6AXW.js";
+} from "./chunk-ANDVK2JN.js";
 import {
   ChannelDeliveryError,
   MAX_CHANNEL_DELIVERY_TEXT_LENGTH
-} from "./chunk-LK7CHLVP.js";
+} from "./chunk-U4VTUMMK.js";
 import {
   redactLogCredentials
 } from "./chunk-M5GB774H.js";
 import {
   getResponseText
-} from "./chunk-PHOF65IG.js";
+} from "./chunk-FRXG4ARO.js";
 import {
   MAX_CHANNEL_DELIVERY_NAME_LENGTH,
   MAX_CHANNEL_DELIVERY_TARGET_ID_LENGTH
-} from "./chunk-FNQ6T3CV.js";
+} from "./chunk-TEGJSJDF.js";
+import {
+  parseGoalSnapshotV2
+} from "./chunk-6FMJLI5M.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -498,7 +501,16 @@ function parseTranscriptReplayState(replay, logger) {
     );
   }
   const cumulativeUsage = isCumulativeUsage(replay["cumulativeUsage"]) ? { ...replay["cumulativeUsage"] } : createReplayCumulativeUsage();
-  return { pendingToolCalls, cumulativeUsage };
+  const rawGoalState = replay["goalState"];
+  const goalState = rawGoalState === void 0 ? void 0 : parseGoalSnapshotV2(rawGoalState);
+  if (logger && rawGoalState !== void 0 && !goalState) {
+    logger.warn("[transcript] replay state dropped a malformed Goal state");
+  }
+  return {
+    pendingToolCalls,
+    cumulativeUsage,
+    ...goalState ? { goalState } : {}
+  };
 }
 __name(parseTranscriptReplayState, "parseTranscriptReplayState");
 function replayContext(sessionId, updates, cumulativeUsage, config) {
@@ -580,7 +592,8 @@ async function replayTranscriptRecordPage({
     const replayPageState = await replayer.replayPage(page.records, {
       pendingToolCalls: page.direction === "backward" ? [] : state.pendingToolCalls,
       finalizeDangling: page.direction === "backward" || !page.hasMore,
-      gaps: page.gaps
+      gaps: page.gaps,
+      ...state.goalState ? { goalState: state.goalState } : {}
     });
     replayState = replayPageState.replay;
   } catch (error) {