@qwen-code/qwen-code 0.22.3 → 0.23.0

package/chunks/{chunk-ABS25QER.js → chunk-ANVG3BVV.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-UHQFIS7N.js";
+} from "./chunk-EAHOJF6V.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-6ZPDLGHN.js → chunk-AZJLY2XZ.js}

@@ -5,26 +5,26 @@ import {
 } from "./chunk-57OAHC2Y.js";
 import {
   loadSettings
-} from "./chunk-AIAOIFY4.js";
+} from "./chunk-VWTSRH6C.js";
 import {
   getCurrentLanguage,
   t
-} from "./chunk-CLWO3B77.js";
+} from "./chunk-I4NRYS6A.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-MF7HCQWZ.js";
+} from "./chunk-65HWLGA7.js";
 import {
   ExtensionManager,
   getExtensionDescription,
   getExtensionDisplayName,
   require_prompts
-} from "./chunk-PZ66FRIC.js";
+} from "./chunk-4F7GQGXB.js";
 import {
   stripAnsi
 } from "./chunk-TWPJO254.js";
 import {
   redactUrlCredentials
-} from "./chunk-B5PHIJGI.js";
+} from "./chunk-QKDNS6FU.js";
 import {
   writeStdoutLine
 } from "./chunk-7FA2II6K.js";

package/chunks/{chunk-A3LWD5MK.js → chunk-BA4WJC4L.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   t
-} from "./chunk-CLWO3B77.js";
+} from "./chunk-I4NRYS6A.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-W3JH33JE.js → chunk-BFY33IB4.js}

@@ -1,11 +1,8 @@
 // Force strict mode and setup for ESM
 "use strict";
-import {
-  DEFAULT_QWEN_MODEL
-} from "./chunk-XZA32HII.js";
 import {
   preloadRuntimeFetchModule
-} from "./chunk-PPKZ7JOE.js";
+} from "./chunk-22UH7VTP.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -13,6 +10,10 @@ import {
   __name
 } from "./chunk-J2S4EL5Y.js";
 
+// packages/core/src/utils/default-qwen-model.ts
+init_esbuild_shims();
+var DEFAULT_QWEN_MODEL = "coder-model";
+
 // packages/core/src/config/models.ts
 init_esbuild_shims();
 var DEFAULT_QWEN_EMBEDDING_MODEL = "text-embedding-v4";
@@ -410,18 +411,18 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
   try {
     if (authType === "openai" /* USE_OPENAI */) {
       loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-        const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-J6QIF7EX.js");
+        const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-ZJIEQ3ZJ.js");
         return createOpenAIContentGenerator(generatorConfig, config);
       }, "loadBaseGenerator");
     } else if (authType === "qwen-oauth" /* QWEN_OAUTH */) {
-      const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-OF5WRBQT.js");
+      const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-7AOCKSOQ.js");
       try {
         const qwenClient = await getQwenOauthClient(
           config,
           isInitialAuth ? { requireCachedCredentials: true } : void 0
         );
         loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-          const { QwenContentGenerator } = await import("./qwenContentGenerator-WWDXPYQI.js");
+          const { QwenContentGenerator } = await import("./qwenContentGenerator-VI4KATRY.js");
           return new QwenContentGenerator(qwenClient, generatorConfig, config);
         }, "loadBaseGenerator");
       } catch (error) {
@@ -432,12 +433,12 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
       }
     } else if (authType === "anthropic" /* USE_ANTHROPIC */) {
       loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-        const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-YVTB6QX7.js");
+        const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-L76MR5OR.js");
         return createAnthropicContentGenerator(generatorConfig, config);
       }, "loadBaseGenerator");
     } else if (authType === "gemini" /* USE_GEMINI */ || authType === "vertex-ai" /* USE_VERTEX_AI */) {
       loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-        const { createLlmContentGenerator } = await import("./llm-content-generator-AY2QKXHE.js");
+        const { createLlmContentGenerator } = await import("./llm-content-generator-TT6EAUD4.js");
         return createLlmContentGenerator(generatorConfig, config);
       }, "loadBaseGenerator");
     } else {
@@ -452,7 +453,7 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
     try {
       const [baseGenerator, { LoggingContentGenerator }] = await Promise.all([
         loadBaseGenerator(),
-        import("./loggingContentGenerator-DSFQHXIF.js")
+        import("./loggingContentGenerator-EYQBA4M4.js")
       ]);
       return new LoggingContentGenerator(
         baseGenerator,
@@ -467,6 +468,7 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
 __name(createContentGenerator, "createContentGenerator");
 
 export {
+  DEFAULT_QWEN_MODEL,
   VERTEX_ADC_HINT,
   DEFAULT_QWEN_EMBEDDING_MODEL,
   MAINLINE_CODER_MODEL,
@@ -482,6 +484,12 @@ export {
   resetPreloadedContentGenerator,
   createContentGenerator
 };
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
 /**
  * @license
  * Copyright 2025 Google LLC

package/chunks/{chunk-N4X7G4J2.js → chunk-BHTYRHJF.js}

@@ -11,7 +11,7 @@ import {
 init_esbuild_shims();
 function mapSkillConfigToStatus(skill, disablements = /* @__PURE__ */ new Map(), opts = {}) {
   const disablement = disablements.get(skill.name.toLowerCase());
-  const disabledReason = opts.disabled ? "inactive_extension" : disablement?.reason;
+  const disabledReason = opts.disabled ? "inactive_extension" : disablement?.reason ?? (opts.enabled === false ? "default" : void 0);
   const modelInvocable = skill.disableModelInvocation !== true;
   return {
     kind: "skill",

package/chunks/{chunk-TEBDFQBZ.js → chunk-BJXCYUGM.js}

@@ -13,6 +13,10 @@ import {
 import {
   isWithinRoot
 } from "./chunk-MR3PXB6E.js";
+import {
+  isUnverifiableIdentityError,
+  openNoFollow
+} from "./chunk-6HUXPLB5.js";
 import {
   require_proper_lockfile
 } from "./chunk-MLXTMF7H.js";
@@ -28,7 +32,6 @@ import {
 init_esbuild_shims();
 var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
 import { createHash } from "node:crypto";
-import { constants } from "node:fs";
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -423,14 +426,16 @@ var WorkspaceRegistrationStore = class {
     }
     let file;
     try {
-      file = await fs.open(
-        this.filePath,
-        (constants.O_RDONLY ?? 0) | (constants.O_NOFOLLOW ?? 0)
-      );
+      file = await openNoFollow(this.filePath);
     } catch (err) {
       if (err.code === "ENOENT") {
         return emptySnapshot(this.primaryWorkspace);
       }
+      if (isUnverifiableIdentityError(err)) {
+        throw new WorkspaceRegistrationStoreError(
+          "Workspace registration store identity could not be verified"
+        );
+      }
       if (err.code === "ELOOP") {
         throw new WorkspaceRegistrationStoreError(
           "Workspace registration store must be a regular file"
@@ -563,7 +568,7 @@ var WorkspaceRegistrationStore = class {
     return removed;
   }
   async update(mutate) {
-    const { atomicWriteFile } = await import("./deferred-core-runtime-WOYLUQQ7.js");
+    const { atomicWriteFile } = await import("./deferred-core-runtime-S32AYVZI.js");
     return withInProcessLock(this.filePath, async () => {
       const lock = await acquireFileLock(this.filePath);
       let committed = false;

package/chunks/{chunk-7VMIMAVB.js → chunk-C2VWOXHS.js}

@@ -2,19 +2,19 @@
 "use strict";
 import {
   loadSettings
-} from "./chunk-AIAOIFY4.js";
+} from "./chunk-VWTSRH6C.js";
 import {
   getCurrentLanguage
-} from "./chunk-CLWO3B77.js";
+} from "./chunk-I4NRYS6A.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-MF7HCQWZ.js";
+} from "./chunk-65HWLGA7.js";
 import {
   require_strip_json_comments
 } from "./chunk-NPQ5ZKRP.js";
 import {
   hashMcpServerConfig
-} from "./chunk-NV55WWD6.js";
+} from "./chunk-JUARRUMA.js";
 import {
   Config,
   ExtensionManager,
@@ -25,18 +25,18 @@ import {
   isGatedMcpScope,
   normalizeClaudeMcpServer,
   runWithTimeout
-} from "./chunk-PZ66FRIC.js";
+} from "./chunk-4F7GQGXB.js";
 import {
   getMCPServerLastError,
   getMCPServerStatus
-} from "./chunk-QYMAKPY5.js";
+} from "./chunk-GH2S4GD5.js";
 import {
   atomicWriteFile
-} from "./chunk-23RFD54N.js";
+} from "./chunk-KHP66DFN.js";
 import {
   Storage,
   getErrorMessage
-} from "./chunk-UHQFIS7N.js";
+} from "./chunk-EAHOJF6V.js";
 import {
   writeStderrLine,
   writeStdoutLine

package/chunks/{chunk-XHF7WQ6B.js → chunk-C4TIXFDZ.js}

@@ -9,10 +9,10 @@ import {
   publishPendingCompileCache,
   reportRejectedLoaderKeys,
   resetLoaderKeyRejectionReportingForTesting
-} from "./chunk-MZCJWS5Y.js";
+} from "./chunk-2M3EWQNG.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-MF7HCQWZ.js";
+} from "./chunk-65HWLGA7.js";
 import {
   require_main
 } from "./chunk-5M6IDOMF.js";
@@ -20,7 +20,7 @@ import {
   QWEN_DIR,
   Storage,
   getErrorMessage
-} from "./chunk-UHQFIS7N.js";
+} from "./chunk-EAHOJF6V.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -428,7 +428,7 @@ function loadEnvironment(settings, startDir = process.cwd()) {
   publishPendingCompileCache();
 }
 __name(loadEnvironment, "loadEnvironment");
-function reloadEnvironment(settings, workspaceCwd, workspaceTrusted) {
+function reloadEnvironment(settings, workspaceCwd, workspaceTrusted, options = {}) {
   const userLevelPaths = getUserLevelEnvPaths();
   const envFilePaths = findEnvFiles(
     settings,
@@ -437,6 +437,13 @@ function reloadEnvironment(settings, workspaceCwd, workspaceTrusted) {
     workspaceTrusted
   );
   const parsedEnvFiles = parseEnvFiles(envFilePaths, userLevelPaths);
+  if (parsedEnvFiles.readFailed && options.failClosedOnEnvFileReadError) {
+    return {
+      updatedKeys: [],
+      removedKeys: [],
+      envFileReadFailed: true
+    };
+  }
   if (process.env["CLOUD_SHELL"] === "true") {
     setUpCloudShellEnvironmentInEnv(process.env, parsedEnvFiles.files);
   }
@@ -523,7 +530,11 @@ function reloadEnvironment(settings, workspaceCwd, workspaceTrusted) {
   for (const key of newSettingsEnvKeys.keys()) {
     settingsEnvSourcedKeys.add(key);
   }
-  return { updatedKeys, removedKeys };
+  return {
+    updatedKeys,
+    removedKeys,
+    ...dotEnvReadFailed ? { envFileReadFailed: true } : {}
+  };
 }
 __name(reloadEnvironment, "reloadEnvironment");
 

package/chunks/chunk-CHEIIBT3.js

@@ -0,0 +1,40 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/utils/formatters.ts
+init_esbuild_shims();
+var BYTES_PER_KB = 1024;
+var BYTES_PER_MB = BYTES_PER_KB * 1024;
+var BYTES_PER_GB = BYTES_PER_MB * 1024;
+var roundedTo = /* @__PURE__ */ __name((value, digits) => Number(value.toFixed(digits)), "roundedTo");
+var formatMemoryUsage = /* @__PURE__ */ __name((bytes) => {
+  if (roundedTo(bytes / BYTES_PER_KB, 1) < 1024) {
+    return `${(bytes / BYTES_PER_KB).toFixed(1)} KB`;
+  }
+  if (roundedTo(bytes / BYTES_PER_MB, 1) < 1024) {
+    return `${(bytes / BYTES_PER_MB).toFixed(1)} MB`;
+  }
+  return `${(bytes / BYTES_PER_GB).toFixed(2)} GB`;
+}, "formatMemoryUsage");
+var JSON_TAG_CHARACTER_ESCAPES = {
+  "<": "\\u003c",
+  ">": "\\u003e",
+  "&": "\\u0026"
+};
+var escapeJsonTagCharacters = /* @__PURE__ */ __name((json) => json.replace(/[<>&]/g, (character) => JSON_TAG_CHARACTER_ESCAPES[character]), "escapeJsonTagCharacters");
+
+export {
+  formatMemoryUsage,
+  escapeJsonTagCharacters
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/chunk-CVX63TFJ.js

@@ -0,0 +1,348 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  isSameProcess,
+  readLocalBootId,
+  readPidNamespaceId,
+  readProcStartToken
+} from "./chunk-373DQUVA.js";
+import {
+  atomicWriteJSON
+} from "./chunk-KHP66DFN.js";
+import {
+  Storage,
+  createDebugLogger
+} from "./chunk-EAHOJF6V.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/services/session-registry.ts
+init_esbuild_shims();
+import { createHash } from "node:crypto";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+var debugLogger = createDebugLogger("SESSION_REGISTRY");
+var SESSION_REGISTRY_SCHEMA_VERSION = 1;
+var REGISTRY_DIR_MODE = 448;
+var REGISTRY_FILE_MODE = 384;
+var MAX_RECORD_BYTES = 64 * 1024;
+var RECORD_FILENAME = /^\d+\.json$/;
+var TEMP_FILENAME = /^\d+\.json\.[0-9a-f]{12}\.tmp$/;
+var TEMP_MAX_AGE_MS = 5 * 60 * 1e3;
+function getSessionRegistryDir() {
+  return path.join(Storage.getGlobalQwenDir(), "sessions");
+}
+__name(getSessionRegistryDir, "getSessionRegistryDir");
+function getSessionRecordPath() {
+  return path.join(getSessionRegistryDir(), `${process.pid}.json`);
+}
+__name(getSessionRecordPath, "getSessionRecordPath");
+var registeredRecordPath = null;
+function thisProcessRecordPath() {
+  return registeredRecordPath ?? getSessionRecordPath();
+}
+__name(thisProcessRecordPath, "thisProcessRecordPath");
+function deriveSessionName(cwd, sessionId) {
+  const base = Array.from(
+    path.basename(cwd).normalize("NFC").replace(/[^\p{L}\p{M}\p{N}._-]+/gu, "-").replace(/^-+|-+$/g, "")
+  ).slice(0, 32).join("");
+  const suffix = createHash("sha256").update(sessionId).digest("hex").slice(0, 2);
+  return `${base || "session"}-${suffix}`;
+}
+__name(deriveSessionName, "deriveSessionName");
+async function registerSession(fields) {
+  let procStart = readProcStartToken(process.pid);
+  if (process.platform === "linux" && procStart === null) {
+    procStart = readProcStartToken(process.pid);
+    if (procStart === null) {
+      debugLogger.debug(
+        "registerSession: start token unreadable; refusing to write an impersonable record"
+      );
+      return false;
+    }
+  }
+  let pidNs = readPidNamespaceId();
+  if (process.platform === "linux" && pidNs === null) {
+    pidNs = readPidNamespaceId();
+    if (pidNs === null) {
+      debugLogger.debug(
+        "registerSession: namespace id unreadable; refusing to write an unreclaimable record"
+      );
+      return false;
+    }
+  }
+  const record = {
+    schemaVersion: SESSION_REGISTRY_SCHEMA_VERSION,
+    pid: process.pid,
+    procStart,
+    pidNs,
+    sessionId: fields.sessionId,
+    cwd: fields.cwd,
+    name: deriveSessionName(fields.cwd, fields.sessionId),
+    startedAt: Date.now(),
+    qwenVersion: fields.qwenVersion ?? null
+  };
+  try {
+    const dir = getSessionRegistryDir();
+    const filePath = getSessionRecordPath();
+    const existing = await readRecord(filePath);
+    if (existing.status === "read-error") {
+      debugLogger.debug(
+        "registerSession: record path read failed transiently; refusing to overwrite an intact record"
+      );
+      return false;
+    }
+    if (existing.status === "unsupported-version") {
+      debugLogger.debug(
+        "registerSession: record path held by a newer-schema record"
+      );
+      return false;
+    }
+    if (existing.status === "ok" && !matchesLocalIdentity(existing.record)) {
+      debugLogger.debug(
+        "registerSession: record path held by a foreign-identity record"
+      );
+      return false;
+    }
+    await fs.mkdir(dir, { recursive: true, mode: REGISTRY_DIR_MODE });
+    try {
+      await fs.chmod(dir, REGISTRY_DIR_MODE);
+    } catch (error) {
+      const code = error?.code;
+      if (code !== "ENOSYS" && code !== "ENOTSUP") throw error;
+    }
+    await atomicWriteJSON(filePath, record, {
+      mode: REGISTRY_FILE_MODE,
+      forceMode: true,
+      noFollow: true
+    });
+    registeredRecordPath = filePath;
+    return true;
+  } catch (error) {
+    debugLogger.debug(`registerSession failed: ${describe(error)}`);
+    return false;
+  }
+}
+__name(registerSession, "registerSession");
+async function patchSessionRecord(patch) {
+  try {
+    const filePath = thisProcessRecordPath();
+    const existing = await readRecord(filePath);
+    if (existing.status !== "ok" || !matchesLocalIdentity(existing.record)) {
+      return false;
+    }
+    const record = existing.record;
+    const currentToken = readProcStartToken(process.pid);
+    if (record.procStart !== null && record.procStart !== currentToken) {
+      return false;
+    }
+    await atomicWriteJSON(
+      filePath,
+      { ...record, ...patch },
+      { mode: REGISTRY_FILE_MODE, forceMode: true, noFollow: true }
+    );
+    return true;
+  } catch (error) {
+    debugLogger.debug(`patchSessionRecord failed: ${describe(error)}`);
+    return false;
+  }
+}
+__name(patchSessionRecord, "patchSessionRecord");
+async function unregisterSession() {
+  try {
+    const filePath = thisProcessRecordPath();
+    registeredRecordPath = null;
+    const existing = await readRecord(filePath);
+    if (existing.status === "unsupported-version" || existing.status === "read-error") {
+      return;
+    }
+    if (existing.status === "ok" && !matchesLocalIdentity(existing.record)) {
+      return;
+    }
+    await fs.unlink(filePath);
+  } catch (error) {
+    if (error?.code === "ENOENT") return;
+    debugLogger.debug(`unregisterSession failed: ${describe(error)}`);
+  }
+}
+__name(unregisterSession, "unregisterSession");
+async function readOwnSessionRecord() {
+  try {
+    const existing = await readRecord(thisProcessRecordPath());
+    if (existing.status !== "ok" || !matchesLocalIdentity(existing.record)) {
+      return null;
+    }
+    const record = existing.record;
+    const currentToken = readProcStartToken(process.pid);
+    if (record.procStart !== null && record.procStart !== currentToken) {
+      return null;
+    }
+    return record;
+  } catch (error) {
+    debugLogger.debug(`readOwnSessionRecord failed: ${describe(error)}`);
+    return null;
+  }
+}
+__name(readOwnSessionRecord, "readOwnSessionRecord");
+async function listLiveSessions() {
+  let dir;
+  let entries;
+  try {
+    dir = getSessionRegistryDir();
+    entries = await fs.readdir(dir);
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      debugLogger.debug(`listLiveSessions readdir failed: ${describe(error)}`);
+    }
+    return [];
+  }
+  const ownNamespace = readPidNamespaceId();
+  const ownBootId = readLocalBootId();
+  const live = [];
+  await Promise.all(
+    entries.map(async (name) => {
+      const filePath = path.join(dir, name);
+      if (!RECORD_FILENAME.test(name)) {
+        await sweepOrphanedTempFile(filePath, name);
+        return;
+      }
+      const read = await readRecord(filePath);
+      if (read.status !== "ok") return;
+      const record = read.record;
+      if (`${record.pid}.json` !== name) return;
+      if (record.pidNs !== ownNamespace) return;
+      const recordBootId = record.procStart === null ? null : bootIdOf(record.procStart);
+      if (recordBootId !== null && recordBootId !== ownBootId) {
+        return;
+      }
+      if (isSameProcess(record.pid, record.procStart)) {
+        live.push(record);
+        return;
+      }
+      const reread = await readRecord(filePath);
+      if (reread.status !== "ok" || reread.record.pid !== record.pid || reread.record.pidNs !== record.pidNs || reread.record.procStart !== record.procStart || reread.record.startedAt !== record.startedAt) {
+        return;
+      }
+      try {
+        await fs.unlink(filePath);
+      } catch {
+      }
+    })
+  );
+  return live.sort((a, b) => b.startedAt - a.startedAt);
+}
+__name(listLiveSessions, "listLiveSessions");
+function matchesLocalIdentity(record) {
+  if (record.pid !== process.pid) return false;
+  if (record.pidNs !== readPidNamespaceId()) return false;
+  if (record.procStart === null) return true;
+  const ownBootId = readLocalBootId();
+  const recordBootId = bootIdOf(record.procStart);
+  if (ownBootId === null) return recordBootId === null;
+  return recordBootId === null || recordBootId === ownBootId;
+}
+__name(matchesLocalIdentity, "matchesLocalIdentity");
+function bootIdOf(procStart) {
+  const sep = procStart.indexOf(":");
+  return sep === -1 ? null : procStart.slice(0, sep);
+}
+__name(bootIdOf, "bootIdOf");
+async function sweepOrphanedTempFile(filePath, name) {
+  if (!TEMP_FILENAME.test(name)) return;
+  try {
+    const stat2 = await fs.stat(filePath);
+    if (!stat2.isFile()) return;
+    if (Date.now() - stat2.mtimeMs < TEMP_MAX_AGE_MS) return;
+    await fs.unlink(filePath);
+  } catch {
+  }
+}
+__name(sweepOrphanedTempFile, "sweepOrphanedTempFile");
+var UNREADABLE = { status: "unreadable" };
+var READ_ERROR = { status: "read-error" };
+var UNSUPPORTED_VERSION = {
+  status: "unsupported-version"
+};
+async function readRecord(filePath) {
+  let raw;
+  try {
+    const stat2 = await fs.stat(filePath);
+    if (!stat2.isFile() || stat2.size > MAX_RECORD_BYTES) return UNREADABLE;
+    raw = await fs.readFile(filePath, "utf8");
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return UNREADABLE;
+    }
+    return READ_ERROR;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return UNREADABLE;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return UNREADABLE;
+  }
+  const value = parsed;
+  const schemaVersion = value["schemaVersion"];
+  if (typeof schemaVersion !== "number") return UNREADABLE;
+  if (schemaVersion > SESSION_REGISTRY_SCHEMA_VERSION) {
+    return UNSUPPORTED_VERSION;
+  }
+  const pid = value["pid"];
+  const sessionId = value["sessionId"];
+  const cwd = value["cwd"];
+  const name = value["name"];
+  const startedAt = value["startedAt"];
+  if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0 || typeof sessionId !== "string" || typeof cwd !== "string" || typeof name !== "string" || typeof startedAt !== "number" || !Number.isFinite(startedAt)) {
+    return UNREADABLE;
+  }
+  const procStart = value["procStart"];
+  const pidNs = value["pidNs"];
+  const qwenVersion = value["qwenVersion"];
+  const ipcPath = value["ipcPath"];
+  const ipcToken = value["ipcToken"];
+  return {
+    status: "ok",
+    record: {
+      schemaVersion,
+      pid,
+      procStart: typeof procStart === "string" ? procStart : null,
+      pidNs: typeof pidNs === "number" && Number.isFinite(pidNs) ? pidNs : null,
+      sessionId,
+      cwd,
+      name,
+      startedAt,
+      qwenVersion: typeof qwenVersion === "string" ? qwenVersion : null,
+      // Optional rather than nulled: absent and empty both mean "not
+      // messageable", and a record written before this field existed must
+      // read back identically to one written after it.
+      ...typeof ipcPath === "string" && ipcPath.length > 0 ? { ipcPath } : {},
+      ...typeof ipcToken === "string" && ipcToken.length > 0 ? { ipcToken } : {}
+    }
+  };
+}
+__name(readRecord, "readRecord");
+function describe(error) {
+  return error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+}
+__name(describe, "describe");
+
+export {
+  deriveSessionName,
+  registerSession,
+  patchSessionRecord,
+  unregisterSession,
+  readOwnSessionRecord,
+  listLiveSessions
+};
+/**
+ * @license
+ * Copyright 2026 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */