@qwen-code/qwen-code 0.22.2-preview.1 → 0.22.3-nightly.20260829.e5cb60ad48

package/chunks/{chunk-EC5BONC3.js → chunk-TPI7O7HR.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   MAX_TERMINAL_IMAGE_BYTES
-} from "./chunk-KOJ6MHD5.js";
+} from "./chunk-UTLCH2FK.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-T2CRBIDJ.js → chunk-TTX2JUE6.js}

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

package/chunks/{chunk-AP7WZONS.js → chunk-TU6WVK67.js}

@@ -6,11 +6,12 @@ import {
   OFFICE_DOCUMENT_EXTENSIONS,
   hasControlCharacter,
   hasUnsafeDisplayPayload,
+  pathHasSkippedDirectoryComponent,
   toCanonicalWorkspaceArtifactPath
-} from "./chunk-SKNVVYIJ.js";
+} from "./chunk-K5KXUXWC.js";
 import {
   checkTeamMemorySecrets
-} from "./chunk-XJS54K4A.js";
+} from "./chunk-VTHREBQM.js";
 import {
   CommitAttributionService,
   FileEncoding,
@@ -19,27 +20,27 @@ import {
   detectLineEnding,
   getDiffStat,
   needsUtf8Bom
-} from "./chunk-XIRDDFRS.js";
+} from "./chunk-ECE3UYVO.js";
 import {
   FileOperationEvent,
   getLanguageFromFilePath,
   logFileOperation
-} from "./chunk-OF2DPXUS.js";
+} from "./chunk-QYMAKPY5.js";
 import {
   fileExists,
   getSpecificMimeType
-} from "./chunk-WBT3STGU.js";
+} from "./chunk-BKWNKLZB.js";
 import {
   isAnyAutoMemPath,
   isTeamAutoMemPath
-} from "./chunk-PVBT5QPD.js";
+} from "./chunk-6PJOTWAN.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   StructuredToolError,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-KOJ6MHD5.js";
+} from "./chunk-UTLCH2FK.js";
 import {
   createDebugLogger,
   getErrorMessage,
@@ -47,7 +48,7 @@ import {
   makeRelative,
   shortenPath,
   unescapePath
-} from "./chunk-2NNTE2ED.js";
+} from "./chunk-UHQFIS7N.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -376,7 +377,7 @@ var WriteFileToolInvocation = class extends BaseToolInvocation {
           `User modified the \`content\` to be: ${content}`
         );
       }
-      const artifact = buildWorkspaceArtifactMetadata(
+      const artifact = this.params.record_as_artifact === false ? null : buildWorkspaceArtifactMetadata(
         this.config,
         file_path,
         postWriteSizeBytes
@@ -498,6 +499,9 @@ function resolveRecordedWorkspaceFile(config, filePath) {
   if (!workspacePath) {
     return null;
   }
+  if (pathHasSkippedDirectoryComponent(workspacePath)) {
+    return null;
+  }
   return { filePath: resolvedFile, workspacePath };
 }
 __name(resolveRecordedWorkspaceFile, "resolveRecordedWorkspaceFile");
@@ -512,6 +516,8 @@ var WriteFileTool = class _WriteFileTool extends BaseDeclarativeTool {
       ToolDisplayNames.WRITE_FILE,
       `Writes content to a specified file in the local filesystem. A request to create or generate a file does not establish that the target path is new. Unless the target's absence or current text contents have already been established in this session, you MUST use the ${ToolNames.READ_FILE} tool first; if the file does not exist, then create it. With prior-read enforcement enabled, blind overwrites are rejected. The file_path argument MUST be an absolute path. Always construct it by combining the project root with the file's relative path (e.g. project root '/path/to/project/' + relative 'foo/bar.txt' = '/path/to/project/foo/bar.txt'). If the user provides a relative path, resolve it against the project root first.
 
+Artifact-like files such as HTML, PDF, images, notebooks, and office documents are automatically registered as session artifacts. Intermediate files that exist only to produce another artifact \u2014 for example HTML written solely to print a PDF \u2014 must set record_as_artifact=false, or be written under .qwen/tmp/ so they are not registered. Delete those intermediates when done.
+
 The user has the ability to modify \`content\`. If modified, this will be stated in the response.`,
       "edit" /* Edit */,
       {
@@ -523,6 +529,10 @@ The user has the ability to modify \`content\`. If modified, this will be stated
           content: {
             description: "The content to write to the file.",
             type: "string"
+          },
+          record_as_artifact: {
+            description: "Set false for intermediate files that should not appear as session artifacts, such as HTML used only to print a PDF. Defaults to true for artifact-like extensions.",
+            type: "boolean"
           }
         },
         required: ["file_path", "content"],

package/chunks/chunk-U54AYGEC.js

@@ -0,0 +1,337 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/utils/conversation-directory-identity.ts
+init_esbuild_shims();
+import { createHash } from "node:crypto";
+import { lstat, mkdir, realpath } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+function hasVerifiableInode(ino) {
+  return Number(ino) !== 0;
+}
+__name(hasVerifiableInode, "hasVerifiableInode");
+var ConversationDirectoryIdentityError = class extends Error {
+  constructor(scope, reason, cause) {
+    super(
+      `Conversation ${scope} identity validation failed: ${reason}`,
+      cause !== void 0 ? { cause } : void 0
+    );
+    this.scope = scope;
+    this.reason = reason;
+  }
+  static {
+    __name(this, "ConversationDirectoryIdentityError");
+  }
+  name = "ConversationDirectoryIdentityError";
+};
+function throwIdentityIoError(scope, cause) {
+  throw new ConversationDirectoryIdentityError(scope, "io_error", cause);
+}
+__name(throwIdentityIoError, "throwIdentityIoError");
+var isSameConversationPath = /* @__PURE__ */ __name((left, right) => process.platform === "win32" ? left.toLowerCase() === right.toLowerCase() : left === right, "isSameConversationPath");
+function getConversationDirectoryName(storageSessionId) {
+  if (storageSessionId.length === 0 || storageSessionId.length > 256) {
+    throw new ConversationDirectoryIdentityError("child", "invalid_session_id");
+  }
+  return `conversation-${createHash("sha256").update(storageSessionId).digest("hex")}`;
+}
+__name(getConversationDirectoryName, "getConversationDirectoryName");
+function getConversationStagedDirectoryName(storageSessionId) {
+  return `${getConversationDirectoryName(storageSessionId)}.deleting`;
+}
+__name(getConversationStagedDirectoryName, "getConversationStagedDirectoryName");
+function validateDirectoryStats(stats, scope) {
+  if (stats.isSymbolicLink() || !stats.isDirectory()) {
+    throw new ConversationDirectoryIdentityError(scope, "not_directory");
+  }
+  if (process.platform !== "win32" && typeof process.getuid === "function" && stats.uid !== process.getuid()) {
+    throw new ConversationDirectoryIdentityError(scope, "wrong_owner");
+  }
+  if (process.platform !== "win32" && (stats.mode & 63) !== 0) {
+    throw new ConversationDirectoryIdentityError(scope, "wrong_mode");
+  }
+}
+__name(validateDirectoryStats, "validateDirectoryStats");
+function hasRootIdentity(stats, root) {
+  if (!root.inodeVerifiable) return stats.dev === root.device;
+  return hasVerifiableInode(stats.ino) && stats.dev === root.device && stats.ino === root.inode;
+}
+__name(hasRootIdentity, "hasRootIdentity");
+function isSameDirectoryIdentity(before, after) {
+  if (!hasVerifiableInode(before.ino) || !hasVerifiableInode(after.ino)) {
+    return before.dev === after.dev;
+  }
+  return before.dev === after.dev && before.ino === after.ino;
+}
+__name(isSameDirectoryIdentity, "isSameDirectoryIdentity");
+function hasExpectedDirectoryIdentity(identity, expected) {
+  const identityInodeVerifiable = hasVerifiableInode(identity.inode);
+  const expectedInodeVerifiable = hasVerifiableInode(expected.inode);
+  return identity.storageSessionId === expected.storageSessionId && identity.name === expected.name && isSameConversationPath(identity.canonicalPath, expected.canonicalPath) && identity.device === expected.device && identityInodeVerifiable === expectedInodeVerifiable && (!identityInodeVerifiable || identity.inode === expected.inode) && isSameConversationPath(
+    identity.root.configuredRoot,
+    expected.root.configuredRoot
+  ) && isSameConversationPath(
+    identity.root.canonicalRoot,
+    expected.root.canonicalRoot
+  ) && identity.root.device === expected.root.device && identity.root.inodeVerifiable === expected.root.inodeVerifiable && (!identity.root.inodeVerifiable || identity.root.inode === expected.root.inode);
+}
+__name(hasExpectedDirectoryIdentity, "hasExpectedDirectoryIdentity");
+async function createConversationRootIdentity(configuredRoot) {
+  try {
+    await mkdir(configuredRoot, { recursive: true, mode: 448 });
+  } catch (error) {
+    let existing;
+    try {
+      existing = await lstat(configuredRoot);
+    } catch {
+      throwIdentityIoError("root", error);
+    }
+    validateDirectoryStats(existing, "root");
+    throwIdentityIoError("root", error);
+  }
+  let before;
+  try {
+    before = await lstat(configuredRoot);
+  } catch (error) {
+    throwIdentityIoError("root", error);
+  }
+  validateDirectoryStats(before, "root");
+  let canonicalRoot;
+  let after;
+  try {
+    canonicalRoot = await realpath(configuredRoot);
+    after = await lstat(canonicalRoot);
+  } catch (error) {
+    throwIdentityIoError("root", error);
+  }
+  validateDirectoryStats(after, "root");
+  if (!isSameDirectoryIdentity(before, after)) {
+    throw new ConversationDirectoryIdentityError("root", "identity_changed");
+  }
+  return {
+    configuredRoot,
+    canonicalRoot,
+    device: after.dev,
+    inode: after.ino,
+    inodeVerifiable: hasVerifiableInode(after.ino)
+  };
+}
+__name(createConversationRootIdentity, "createConversationRootIdentity");
+async function revalidateConversationRootIdentity(root) {
+  let configuredStats;
+  try {
+    configuredStats = await lstat(root.configuredRoot);
+  } catch (error) {
+    throwIdentityIoError("root", error);
+  }
+  validateDirectoryStats(configuredStats, "root");
+  if (!hasRootIdentity(configuredStats, root)) {
+    throw new ConversationDirectoryIdentityError("root", "identity_changed");
+  }
+  let canonical;
+  try {
+    canonical = await realpath(root.configuredRoot);
+  } catch (error) {
+    throwIdentityIoError("root", error);
+  }
+  if (!isSameConversationPath(canonical, root.canonicalRoot)) {
+    throw new ConversationDirectoryIdentityError(
+      "root",
+      "canonical_path_changed"
+    );
+  }
+  let canonicalStats;
+  try {
+    canonicalStats = await lstat(root.canonicalRoot);
+  } catch (error) {
+    throwIdentityIoError("root", error);
+  }
+  validateDirectoryStats(canonicalStats, "root");
+  if (!hasRootIdentity(canonicalStats, root)) {
+    throw new ConversationDirectoryIdentityError("root", "identity_changed");
+  }
+  return root;
+}
+__name(revalidateConversationRootIdentity, "revalidateConversationRootIdentity");
+async function assertExactConversationRootIdentity(root, candidate) {
+  await revalidateConversationRootIdentity(root);
+  const resolvedCandidate = resolve(candidate);
+  if (!isSameConversationPath(resolvedCandidate, root.configuredRoot) && !isSameConversationPath(resolvedCandidate, root.canonicalRoot)) {
+    throw new ConversationDirectoryIdentityError("root", "unexpected_identity");
+  }
+  let stats;
+  let canonical;
+  try {
+    stats = await lstat(resolvedCandidate);
+    validateDirectoryStats(stats, "root");
+    canonical = await realpath(resolvedCandidate);
+  } catch (error) {
+    if (error instanceof ConversationDirectoryIdentityError) throw error;
+    throwIdentityIoError("root", error);
+  }
+  if (!isSameConversationPath(canonical, root.canonicalRoot) || !hasRootIdentity(stats, root)) {
+    throw new ConversationDirectoryIdentityError("root", "unexpected_identity");
+  }
+  return root;
+}
+__name(assertExactConversationRootIdentity, "assertExactConversationRootIdentity");
+async function inspectConversationNamedDirectoryIdentity(root, storageSessionId, name, expected) {
+  await revalidateConversationRootIdentity(root);
+  const candidate = join(root.canonicalRoot, name);
+  let before;
+  try {
+    before = await lstat(candidate);
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throwIdentityIoError("child", error);
+  }
+  validateDirectoryStats(before, "child");
+  let canonical;
+  let after;
+  try {
+    canonical = await realpath(candidate);
+    after = await lstat(canonical);
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throwIdentityIoError("child", error);
+  }
+  validateDirectoryStats(after, "child");
+  const child = relative(root.canonicalRoot, canonical);
+  if (child !== name || child.includes(sep) || child.startsWith("..") || isAbsolute(child)) {
+    throw new ConversationDirectoryIdentityError("child", "not_direct_child");
+  }
+  if (!isSameDirectoryIdentity(before, after)) {
+    throw new ConversationDirectoryIdentityError("child", "identity_changed");
+  }
+  await revalidateConversationRootIdentity(root);
+  const identity = {
+    root,
+    storageSessionId,
+    name,
+    canonicalPath: canonical,
+    device: after.dev,
+    inode: after.ino
+  };
+  if (expected && !hasExpectedDirectoryIdentity(identity, expected)) {
+    throw new ConversationDirectoryIdentityError(
+      "child",
+      "unexpected_identity"
+    );
+  }
+  return identity;
+}
+__name(inspectConversationNamedDirectoryIdentity, "inspectConversationNamedDirectoryIdentity");
+async function inspectConversationDirectoryIdentity(root, storageSessionId, expected) {
+  return inspectConversationNamedDirectoryIdentity(
+    root,
+    storageSessionId,
+    getConversationDirectoryName(storageSessionId),
+    expected
+  );
+}
+__name(inspectConversationDirectoryIdentity, "inspectConversationDirectoryIdentity");
+async function inspectConversationStagedDirectoryIdentity(root, storageSessionId) {
+  return inspectConversationNamedDirectoryIdentity(
+    root,
+    storageSessionId,
+    getConversationStagedDirectoryName(storageSessionId)
+  );
+}
+__name(inspectConversationStagedDirectoryIdentity, "inspectConversationStagedDirectoryIdentity");
+function isSameConversationDirectoryObject(identity, expected) {
+  const identityInodeVerifiable = hasVerifiableInode(identity.inode);
+  const expectedInodeVerifiable = hasVerifiableInode(expected.inode);
+  return identity.storageSessionId === expected.storageSessionId && identity.device === expected.device && identityInodeVerifiable === expectedInodeVerifiable && (!identityInodeVerifiable || identity.inode === expected.inode) && isSameConversationPath(
+    identity.root.canonicalRoot,
+    expected.root.canonicalRoot
+  ) && identity.root.device === expected.root.device && identity.root.inodeVerifiable === expected.root.inodeVerifiable && (!identity.root.inodeVerifiable || identity.root.inode === expected.root.inode);
+}
+__name(isSameConversationDirectoryObject, "isSameConversationDirectoryObject");
+async function materializeConversationDirectoryIdentity(root, storageSessionId) {
+  await revalidateConversationRootIdentity(root);
+  const name = getConversationDirectoryName(storageSessionId);
+  const candidate = join(root.canonicalRoot, name);
+  let created = false;
+  try {
+    await mkdir(candidate, { mode: 448 });
+    created = true;
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throwIdentityIoError("child", error);
+    }
+  }
+  const identity = await inspectConversationDirectoryIdentity(
+    root,
+    storageSessionId
+  );
+  if (!identity) {
+    throw new ConversationDirectoryIdentityError("child", "identity_changed");
+  }
+  return { identity, created };
+}
+__name(materializeConversationDirectoryIdentity, "materializeConversationDirectoryIdentity");
+
+// packages/core/dist/src/services/tool-write-origin.js
+init_esbuild_shims();
+var TOOL_WRITE_ORIGIN_META_KEY = "qwen-code/tool-write-origin";
+var TOOL_WRITE_ORIGINS = [
+  "write_file",
+  "edit",
+  "notebook_edit",
+  "shell_sed_edit"
+];
+var TOOL_WRITE_ORIGIN_SET = new Set(TOOL_WRITE_ORIGINS);
+function buildToolWriteOriginMeta(meta, source) {
+  const sanitized = { ...meta };
+  delete sanitized[TOOL_WRITE_ORIGIN_META_KEY];
+  if (source !== void 0) {
+    sanitized[TOOL_WRITE_ORIGIN_META_KEY] = { version: 1, source };
+  }
+  return Object.keys(sanitized).length > 0 ? sanitized : void 0;
+}
+__name(buildToolWriteOriginMeta, "buildToolWriteOriginMeta");
+function parseToolWriteOriginMeta(meta) {
+  const marker = meta?.[TOOL_WRITE_ORIGIN_META_KEY];
+  if (typeof marker !== "object" || marker === null || Array.isArray(marker)) {
+    return void 0;
+  }
+  const keys = Object.keys(marker);
+  if (keys.length !== 2 || !Object.hasOwn(marker, "version") || !Object.hasOwn(marker, "source")) {
+    return void 0;
+  }
+  const record = marker;
+  return record["version"] === 1 && typeof record["source"] === "string" && TOOL_WRITE_ORIGIN_SET.has(record["source"]) ? record["source"] : void 0;
+}
+__name(parseToolWriteOriginMeta, "parseToolWriteOriginMeta");
+
+export {
+  buildToolWriteOriginMeta,
+  parseToolWriteOriginMeta,
+  ConversationDirectoryIdentityError,
+  isSameConversationPath,
+  getConversationDirectoryName,
+  getConversationStagedDirectoryName,
+  createConversationRootIdentity,
+  revalidateConversationRootIdentity,
+  assertExactConversationRootIdentity,
+  inspectConversationDirectoryIdentity,
+  inspectConversationStagedDirectoryIdentity,
+  isSameConversationDirectoryObject,
+  materializeConversationDirectoryIdentity
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-3WBMPR3S.js → chunk-UAOTD2BN.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   runExitCleanup
-} from "./chunk-TFV4RXPU.js";
+} from "./chunk-K6CTN5TU.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-2NNTE2ED.js → chunk-UHQFIS7N.js}

@@ -1108,6 +1108,21 @@ var Storage = class _Storage {
   getWorkflowRunsDir() {
     return path2.join(this.getProjectDir(), "workflows");
   }
+  /**
+   * Generated-workflow scripts directory: `<projectDir>/workflows/generated`.
+   * A trusted root for `Workflow({scriptPath})` / `workflow({scriptPath})`
+   * that is NOT a saved-workflow scope: scripts here are never listed as
+   * `/<name>` slash commands and cannot be reached by `workflow('<name>')`.
+   * It exists for tooling that emits a script for one run (a CLI subcommand
+   * generating a fan-out for the model to dispatch) — such a script has no
+   * business in the user's command namespace, and the runtime dir keeps it
+   * out of the project tree. Layout below the root is the writer's; the
+   * loader trusts the whole subtree. A subprocess reaches it as
+   * `$QWEN_CODE_PROJECT_DIR/workflows/generated`.
+   */
+  getGeneratedWorkflowsDir() {
+    return path2.join(this.getWorkflowRunsDir(), "generated");
+  }
   /**
    * Path to the persisted snapshot of a completed workflow run.
    */