@qwen-code/qwen-code 0.19.5 → 0.19.6-nightly.20260704.5dc2e1501

package/chunks/{chunk-ZISMVA6U.js → chunk-WGCLCXAN.js}

@@ -34,9 +34,14 @@ import {
   EVENT_SCHEMA_VERSION,
   EventBus
 } from "./chunk-ALX6BUYW.js";
+import {
+  ClientSideConnection,
+  PROTOCOL_VERSION,
+  RequestError
+} from "./chunk-VRDMOSQS.js";
 import {
   defaultSpawnChannelFactory
-} from "./chunk-EROWZQN7.js";
+} from "./chunk-2HK52TS2.js";
 import {
   BridgeChannelClosedError,
   BridgeTimeoutError,
@@ -45,20 +50,15 @@ import {
   STATUS_SCHEMA_VERSION,
   createIdleWorkspaceExtensionsStatus,
   createIdleWorkspaceHooksStatus
-} from "./chunk-LHMZCIKL.js";
-import {
-  ClientSideConnection,
-  PROTOCOL_VERSION,
-  RequestError
-} from "./chunk-UFC57OYT.js";
+} from "./chunk-SZFYG244.js";
 import {
   ShellExecutionService,
   TrustGateError
-} from "./chunk-6QTCOQX7.js";
+} from "./chunk-B5ZACOMA.js";
 import {
   DAEMON_TRACEPARENT_META_KEY,
   DAEMON_TRACESTATE_META_KEY
-} from "./chunk-CHY5C5T4.js";
+} from "./chunk-TDMIHT6B.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -69,7 +69,7 @@ import {
 // packages/acp-bridge/src/bridge.ts
 init_esbuild_shims();
 import { randomUUID as randomUUID2 } from "node:crypto";
-import * as path2 from "node:path";
+import * as path3 from "node:path";
 
 // packages/acp-bridge/src/compactionEngine.ts
 init_esbuild_shims();
@@ -943,8 +943,8 @@ var MultiClientPermissionMediator = class {
     }
     this.resolved.set(record.requestId, record);
     while (this.resolvedOrder.length > MAX_RESOLVED_PERMISSION_RECORDS) {
-      const oldest = this.resolvedOrder.shift();
-      if (oldest !== void 0) this.resolved.delete(oldest);
+      const oldest2 = this.resolvedOrder.shift();
+      if (oldest2 !== void 0) this.resolved.delete(oldest2);
     }
   }
   safeEmit(sessionId, event) {
@@ -1035,10 +1035,108 @@ var MultiClientPermissionMediator = class {
 };
 
 // packages/acp-bridge/src/bridgeClient.ts
+var PUBLISH_ARTIFACT_TOOL_NAME = "artifact";
 function isFsErrorShape(err) {
   return err instanceof Error && err.name === "FsError" && typeof err.kind === "string";
 }
 __name(isFsErrorShape, "isFsErrorShape");
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function artifactPayloadFields(artifact) {
+  return {
+    title: artifact["title"],
+    kind: artifact["kind"],
+    storage: artifact["storage"],
+    description: artifact["description"],
+    workspacePath: artifact["workspacePath"],
+    managedId: artifact["managedId"],
+    url: artifact["url"],
+    mimeType: artifact["mimeType"],
+    sizeBytes: artifact["sizeBytes"],
+    metadata: artifact["metadata"]
+  };
+}
+__name(artifactPayloadFields, "artifactPayloadFields");
+function extractCappedArtifactInputs(rawArtifacts, limit, sessionId, source, toInput) {
+  const artifacts = [];
+  for (let index = 0; index < rawArtifacts.length; index++) {
+    const artifact = rawArtifacts[index];
+    if (!isRecord(artifact)) {
+      writeStderrLine(
+        `[artifacts] session=${sessionId} action=dropped reason=malformed source=${source} index=${index}`
+      );
+      continue;
+    }
+    if (artifacts.length >= limit) {
+      writeStderrLine(
+        `[artifacts] session=${sessionId} action=dropped reason="artifact batch limit exceeded" source=${source} dropped=${rawArtifacts.length - index}`
+      );
+      break;
+    }
+    artifacts.push(toInput(artifact));
+  }
+  return artifacts;
+}
+__name(extractCappedArtifactInputs, "extractCappedArtifactInputs");
+function artifactIngestionErrorReason(error) {
+  if (!(error instanceof Error)) {
+    return String(error);
+  }
+  return {
+    name: error.name,
+    message: error.message,
+    stack: error.stack?.split("\n").slice(0, 4).join("\n")
+  };
+}
+__name(artifactIngestionErrorReason, "artifactIngestionErrorReason");
+function extractSessionUpdateArtifacts(params, updateMeta, limit, sessionId) {
+  const rawArtifacts = updateMeta?.["artifacts"];
+  if (!Array.isArray(rawArtifacts)) {
+    return [];
+  }
+  const update = params.update;
+  if (update.sessionUpdate !== "tool_call_update" || update.status !== "completed" && update.status !== "failed" && update.status !== "cancelled") {
+    return [];
+  }
+  const toolCallId = typeof update.toolCallId === "string" ? update.toolCallId : void 0;
+  const toolName = typeof updateMeta?.["toolName"] === "string" ? updateMeta["toolName"] : void 0;
+  return extractCappedArtifactInputs(
+    rawArtifacts,
+    limit,
+    sessionId,
+    "tool",
+    (artifact) => ({
+      ...artifactPayloadFields(artifact),
+      source: "tool",
+      toolCallId,
+      toolName
+    })
+  );
+}
+__name(extractSessionUpdateArtifacts, "extractSessionUpdateArtifacts");
+function sanitizeSessionUpdateArtifacts(params, updateMeta) {
+  if (!Array.isArray(updateMeta?.["artifacts"])) {
+    return params;
+  }
+  const sanitizedMeta = { ...updateMeta };
+  delete sanitizedMeta["artifacts"];
+  const update = {
+    ...params.update,
+    _meta: sanitizedMeta
+  };
+  return {
+    ...params,
+    update
+  };
+}
+__name(sanitizeSessionUpdateArtifacts, "sanitizeSessionUpdateArtifacts");
+function isTrustedArtifactToolUpdate(params, updateMeta) {
+  const update = params.update;
+  return update.sessionUpdate === "tool_call_update" && update.status === "completed" && updateMeta?.["toolName"] === PUBLISH_ARTIFACT_TOOL_NAME;
+}
+__name(isTrustedArtifactToolUpdate, "isTrustedArtifactToolUpdate");
 function preserveFsErrorOverAcp(err) {
   if (isFsErrorShape(err)) {
     throw new RequestError(-32603, err.message, {
@@ -1100,7 +1198,7 @@ function sliceLineRange(content, startLine, endLine) {
 }
 __name(sliceLineRange, "sliceLineRange");
 var BridgeClient = class {
-  constructor(resolveEntry, resolvePendingRestoreEvents, mediator, permissionTimeoutMs, maxPendingPerSession, fileSystem, onModelPromoted, onModePromoted, clientMcpSender) {
+  constructor(resolveEntry, resolvePendingRestoreEvents, mediator, permissionTimeoutMs, maxPendingPerSession, fileSystem, onModelPromoted, onModePromoted, clientMcpSender, ownsSession = () => true) {
     this.resolveEntry = resolveEntry;
     this.resolvePendingRestoreEvents = resolvePendingRestoreEvents;
     this.mediator = mediator;
@@ -1110,6 +1208,7 @@ var BridgeClient = class {
     this.onModelPromoted = onModelPromoted;
     this.onModePromoted = onModePromoted;
     this.clientMcpSender = clientMcpSender;
+    this.ownsSession = ownsSession;
   }
   static {
     __name(this, "BridgeClient");
@@ -1163,6 +1262,12 @@ var BridgeClient = class {
     }
   }
   async sessionUpdate(params) {
+    if (!this.ownsSession(params.sessionId) && !this.inFlightRestoreIds.has(params.sessionId)) {
+      writeStderrLine(
+        `[demux] session=${params.sessionId} type=session_update action=dropped reason=session_not_owned`
+      );
+      return;
+    }
     const entry = this.resolveEntry(params.sessionId);
     const events = entry?.events ?? this.resolvePendingRestoreEvents(params.sessionId);
     if (!events) return;
@@ -1192,12 +1297,26 @@ var BridgeClient = class {
     const updateMeta = params.update._meta;
     const originalTs = updateMeta?.["serverTimestamp"] ?? updateMeta?.["timestamp"];
     const serverTimestamp = typeof originalTs === "number" && Number.isFinite(originalTs) ? originalTs : void 0;
+    const artifacts = entry?.artifacts ? extractSessionUpdateArtifacts(
+      params,
+      updateMeta,
+      entry.artifacts.inputBatchLimit(),
+      entry.sessionId
+    ) : [];
+    const publishParams = sanitizeSessionUpdateArtifacts(params, updateMeta);
     events.publish({
       type: "session_update",
-      data: params,
+      data: publishParams,
       ...originator,
       ...serverTimestamp !== void 0 ? { _meta: { serverTimestamp } } : {}
     });
+    if (entry) {
+      if (artifacts.length > 0) {
+        await this.upsertAndPublishArtifacts(entry, artifacts, {
+          trustedPublisher: isTrustedArtifactToolUpdate(params, updateMeta)
+        });
+      }
+    }
   }
   /**
    * Bounded early-event buffer. Frames are keyed by sessionId; each
@@ -1335,11 +1454,12 @@ var BridgeClient = class {
     return { payload: response };
   }
   /**
-   * Handle child->bridge ACP `extNotification` calls. Six methods are
-   * recognized — `qwen/notify/session/model-update`,
+   * Handle child->bridge ACP `extNotification` calls. Recognized methods are
+   * `qwen/notify/session/model-update`,
    * `qwen/notify/session/mode-update`,
    * `qwen/notify/session/title-update` (auto/in-process session titles),
    * `qwen/notify/session/prompt-suggestion` (followup assist),
+   * `qwen/notify/session/artifact-event` (hook artifacts),
    * `qwen/notify/session/terminal-sequence`, and
    * `qwen/notify/session/mcp-budget-event` — each translated into a
    * session-scoped SSE frame. Unknown methods are dropped silently
@@ -1401,6 +1521,10 @@ var BridgeClient = class {
       this.publishExtNotification(sessionId2, "terminal_sequence", rest2);
       return;
     }
+    if (method === "qwen/notify/session/artifact-event") {
+      await this.handleArtifactEvent(params);
+      return;
+    }
     if (method !== "qwen/notify/session/mcp-budget-event") return;
     const sessionId = params["sessionId"];
     if (typeof sessionId !== "string") return;
@@ -1419,6 +1543,67 @@ var BridgeClient = class {
     void _kind;
     this.publishExtNotification(sessionId, type, rest);
   }
+  async handleArtifactEvent(params) {
+    const sessionId = params["sessionId"];
+    const rawArtifacts = params["artifacts"];
+    if (typeof sessionId !== "string" || !Array.isArray(rawArtifacts)) {
+      writeStderrLine(
+        `[demux] session=${typeof sessionId === "string" ? sessionId : "<missing>"} type=artifact_event action=dropped reason=malformed`
+      );
+      return;
+    }
+    if (!this.ownsSession(sessionId) && !this.inFlightRestoreIds.has(sessionId)) {
+      writeStderrLine(
+        `[demux] session=${sessionId} type=artifact_event action=dropped reason=session_not_owned`
+      );
+      return;
+    }
+    const entry = this.resolveEntry(sessionId);
+    if (!entry) {
+      writeStderrLine(
+        `[demux] session=${sessionId} type=artifact_event action=dropped reason=session_not_found`
+      );
+      return;
+    }
+    const hookEventName = typeof params["hookEventName"] === "string" ? params["hookEventName"] : void 0;
+    const toolName = typeof params["toolName"] === "string" ? params["toolName"] : void 0;
+    const toolCallId = typeof params["toolCallId"] === "string" ? params["toolCallId"] : void 0;
+    const artifacts = extractCappedArtifactInputs(
+      rawArtifacts,
+      entry.artifacts.inputBatchLimit(),
+      entry.sessionId,
+      "hook",
+      (artifact) => ({
+        ...artifactPayloadFields(artifact),
+        source: "hook",
+        hookEventName,
+        toolName,
+        toolCallId
+      })
+    );
+    await this.upsertAndPublishArtifacts(entry, artifacts);
+  }
+  async upsertAndPublishArtifacts(entry, artifacts, options) {
+    try {
+      const result = await entry.artifacts.upsertMany(artifacts, options);
+      this.publishArtifactChanges(entry, result.changes);
+    } catch (error) {
+      writeStderrLine(
+        `[artifacts] session=${entry.sessionId} action=dropped reason=${JSON.stringify(
+          artifactIngestionErrorReason(error)
+        )}`
+      );
+    }
+  }
+  publishArtifactChanges(entry, changes) {
+    for (const change of changes) {
+      entry.events.publish({
+        type: "artifact_changed",
+        data: { sessionId: entry.sessionId, change },
+        ...entry.activePromptOriginatorClientId ? { originatorClientId: entry.activePromptOriginatorClientId } : {}
+      });
+    }
+  }
   publishExtNotification(sessionId, type, data) {
     const entry = this.resolveEntry(sessionId);
     const frame = {
@@ -1858,6 +2043,1005 @@ function extractA2uiToolUpdate(params) {
 }
 __name(extractA2uiToolUpdate, "extractA2uiToolUpdate");
 
+// packages/acp-bridge/src/sessionArtifacts.ts
+init_esbuild_shims();
+import { createHash } from "node:crypto";
+import { promises as fs2 } from "node:fs";
+import path2 from "node:path";
+var SOURCE_RESERVATIONS = {
+  tool: 100,
+  client: 50,
+  hook: 50
+};
+var WORKSPACE_STATUS_REFRESH_TTL_MS = 5e3;
+var WORKSPACE_STATUS_REFRESH_BATCH_SIZE = 20;
+var SessionArtifactValidationError = class extends Error {
+  constructor(message, field) {
+    super(message);
+    this.field = field;
+    this.name = "SessionArtifactValidationError";
+  }
+  static {
+    __name(this, "SessionArtifactValidationError");
+  }
+  code = "VALIDATION_FAILED";
+};
+var SessionArtifactStore = class {
+  static {
+    __name(this, "SessionArtifactStore");
+  }
+  sessionId;
+  workspaceCwd;
+  maxArtifacts;
+  artifacts = /* @__PURE__ */ new Map();
+  receivedSeq = 0;
+  insertSeq = 0;
+  realWorkspaceCwdPromise;
+  operationQueue = Promise.resolve();
+  constructor(options) {
+    this.sessionId = options.sessionId;
+    this.workspaceCwd = options.workspaceCwd;
+    this.maxArtifacts = options.maxArtifacts ?? 200;
+  }
+  inputBatchLimit() {
+    return this.maxArtifacts * 2;
+  }
+  async list() {
+    return this.enqueue(async () => {
+      await this.refreshWorkspaceStatuses();
+      return {
+        v: 1,
+        sessionId: this.sessionId,
+        artifacts: Array.from(this.artifacts.values()).sort((a, b) => a.insertSeq - b.insertSeq).map(toPublicArtifact),
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        limits: { maxArtifacts: this.maxArtifacts }
+      };
+    });
+  }
+  async upsertMany(inputs, options = {}) {
+    return this.enqueue(async () => {
+      const normalizedResults = [];
+      for (const input of inputs) {
+        try {
+          normalizedResults.push(
+            await this.normalizeInput(
+              input,
+              ++this.receivedSeq,
+              options.trustedPublisher === true
+            )
+          );
+        } catch (error) {
+          if (options.strict) {
+            throw error;
+          }
+          const message = error instanceof Error ? error.message : String(error);
+          writeStderrLine(
+            `[artifacts] session=${this.sessionId} action=dropped reason=${JSON.stringify(
+              message
+            )}`
+          );
+        }
+      }
+      const changes = [];
+      for (const artifact of coalesceByIdentity(normalizedResults)) {
+        const existing = this.artifacts.get(artifact.id) ?? this.findPublishedUpgradeTarget(artifact) ?? this.findPublishedWorkspaceTarget(artifact);
+        if (!existing) {
+          const stored = {
+            ...artifact,
+            insertSeq: ++this.insertSeq
+          };
+          this.artifacts.set(stored.id, stored);
+          changes.push({
+            action: "created",
+            artifactId: stored.id,
+            artifact: toPublicArtifact(stored)
+          });
+          continue;
+        }
+        const updated = mergeArtifact(existing, artifact);
+        if (updated.changed) {
+          if (updated.artifact.id !== existing.id) {
+            this.artifacts.delete(existing.id);
+          }
+          this.artifacts.set(updated.artifact.id, updated.artifact);
+          changes.push({
+            action: "updated",
+            artifactId: updated.artifact.id,
+            artifact: toPublicArtifact(updated.artifact)
+          });
+        }
+      }
+      const createdIds = new Set(
+        changes.filter((change) => change.action === "created").map((change) => change.artifactId)
+      );
+      changes.push(...await this.evictOverflow(createdIds, changes));
+      return { v: 1, sessionId: this.sessionId, changes };
+    });
+  }
+  findPublishedUpgradeTarget(artifact) {
+    if (artifact.storage !== "published" || !artifact.trustedPublisher || !artifact.managedId || !artifact.url) {
+      return void 0;
+    }
+    const byUrl = this.artifacts.get(
+      stableArtifactId(this.sessionId, `url:${artifact.url}`)
+    );
+    if (byUrl && (byUrl.storage !== "published" || byUrl.managedId === artifact.managedId)) {
+      return byUrl;
+    }
+    for (const existing of this.artifacts.values()) {
+      if (existing.storage === "workspace" && existing.workspacePath && artifact.managedId === managedIdForWorkspacePath(
+        this.workspaceCwd,
+        existing.workspacePath
+      ) || existing.storage === "published" && existing.managedId === artifact.managedId) {
+        return existing;
+      }
+    }
+    return void 0;
+  }
+  findPublishedWorkspaceTarget(artifact) {
+    if (artifact.storage !== "workspace" || !artifact.workspacePath) {
+      return void 0;
+    }
+    const managedId = managedIdForWorkspacePath(
+      this.workspaceCwd,
+      artifact.workspacePath
+    );
+    for (const existing of this.artifacts.values()) {
+      if (existing.storage === "published" && existing.managedId === managedId) {
+        return existing;
+      }
+    }
+    return void 0;
+  }
+  async remove(artifactId, options) {
+    return this.enqueue(async () => {
+      const existing = this.artifacts.get(artifactId);
+      if (!existing) {
+        return { v: 1, sessionId: this.sessionId, changes: [] };
+      }
+      if (existing.source === "client" && existing.clientId !== void 0 && existing.clientId !== options?.clientId) {
+        writeStderrLine(
+          `[artifacts] session=${this.sessionId} action=remove_denied artifactId=${artifactId} owner=${existing.clientId} requester=${options?.clientId ?? "<anonymous>"}`
+        );
+        return { v: 1, sessionId: this.sessionId, changes: [] };
+      }
+      this.artifacts.delete(artifactId);
+      return {
+        v: 1,
+        sessionId: this.sessionId,
+        changes: [
+          {
+            action: "removed",
+            artifactId,
+            artifact: toPublicArtifact(existing),
+            reason: "explicit"
+          }
+        ]
+      };
+    });
+  }
+  enqueue(operation) {
+    const result = this.operationQueue.then(operation, operation);
+    this.operationQueue = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  }
+  async normalizeInput(input, receivedSeq, trustedPublisherFromCaller) {
+    if (!input || typeof input !== "object") {
+      throw new SessionArtifactValidationError("Artifact must be an object");
+    }
+    const title = normalizeString(input.title, "title", 200, true);
+    const description = normalizeString(
+      input.description,
+      "description",
+      1e3,
+      false
+    );
+    const source = input.source ?? "tool";
+    if (source !== "tool" && source !== "hook" && source !== "client") {
+      throw new SessionArtifactValidationError(
+        "source must be tool, hook, or client",
+        "source"
+      );
+    }
+    const trustedPublisher = trustedPublisherFromCaller;
+    const workspacePath = input.workspacePath ? normalizeWorkspacePath(input.workspacePath, this.workspaceCwd) : void 0;
+    const managedId = normalizeManagedId(input.managedId);
+    const rawStorage = input.storage;
+    const storage = inferStorage(rawStorage, {
+      workspacePath,
+      managedId,
+      url: input.url,
+      trustedPublisher
+    });
+    const url = input.url ? normalizeArtifactUrl(input.url, trustedPublisher) : void 0;
+    validateLocator(storage, {
+      workspacePath,
+      managedId,
+      url,
+      trustedPublisher
+    });
+    const metadata = normalizeMetadata(input.metadata);
+    const workspaceStatus = workspacePath ? await this.getInitialWorkspaceStatus(workspacePath) : void 0;
+    if (workspaceStatus?.escaped) {
+      throw new SessionArtifactValidationError(
+        "workspacePath must stay inside the workspace",
+        "workspacePath"
+      );
+    }
+    const kind = normalizeKind(
+      input.kind ?? inferKind({ storage, workspacePath, url })
+    );
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const identityKey = buildIdentityKey({
+      storage,
+      workspacePath,
+      managedId,
+      url
+    });
+    const id = stableArtifactId(this.sessionId, identityKey);
+    return {
+      id,
+      identityKey,
+      receivedSeq,
+      retentionSource: source,
+      trustedPublisher,
+      kind,
+      storage,
+      source,
+      status: workspaceStatus?.status ?? "available",
+      ...workspacePath ? { lastStatAt: Date.now() } : {},
+      title,
+      description,
+      workspacePath,
+      managedId,
+      url,
+      mimeType: normalizeString(input.mimeType, "mimeType", 120, false),
+      sizeBytes: input.sizeBytes !== void 0 ? normalizeSizeBytes(input.sizeBytes) : workspaceStatus?.sizeBytes,
+      metadata,
+      clientRetained: source === "client",
+      createdAt: now,
+      updatedAt: now,
+      toolCallId: normalizeString(input.toolCallId, "toolCallId", 200, false),
+      toolName: normalizeString(input.toolName, "toolName", 200, false),
+      hookEventName: normalizeString(
+        input.hookEventName,
+        "hookEventName",
+        200,
+        false
+      ),
+      clientId: normalizeString(input.clientId, "clientId", 200, false)
+    };
+  }
+  async refreshWorkspaceStatuses() {
+    const now = Date.now();
+    const staleWorkspaceArtifacts = Array.from(this.artifacts.values()).filter((artifact) => artifact.workspacePath).filter((artifact) => shouldRefreshWorkspaceStatus(artifact, now));
+    await runInBatches(
+      staleWorkspaceArtifacts,
+      WORKSPACE_STATUS_REFRESH_BATCH_SIZE,
+      (artifact) => this.refreshWorkspaceStatus(artifact, {
+        onError: "missing",
+        now
+      })
+    );
+  }
+  async getInitialWorkspaceStatus(workspacePath) {
+    try {
+      return await getWorkspaceStatus(
+        this.workspaceCwd,
+        workspacePath,
+        this.getRealWorkspaceCwd()
+      );
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      throw new SessionArtifactValidationError(
+        `workspacePath could not be inspected: ${reason}`,
+        "workspacePath"
+      );
+    }
+  }
+  async refreshWorkspaceStatus(artifact, options) {
+    if (!artifact.workspacePath) {
+      return;
+    }
+    try {
+      const status = await getWorkspaceStatus(
+        this.workspaceCwd,
+        artifact.workspacePath,
+        this.getRealWorkspaceCwd()
+      );
+      artifact.status = status.status;
+      artifact.sizeBytes = status.sizeBytes;
+      if (status.escaped) {
+        artifact.status = "missing";
+        artifact.sizeBytes = void 0;
+        delete artifact.workspacePath;
+      }
+      artifact.lastStatAt = options.now ?? Date.now();
+    } catch (error) {
+      writeStderrLine(
+        `[artifacts] session=${this.sessionId} action=status_refresh_failed artifactId=${artifact.id} reason=${JSON.stringify(
+          error instanceof Error ? error.message : String(error)
+        )}`
+      );
+      if (options.onError === "missing") {
+        artifact.status = "missing";
+        artifact.sizeBytes = void 0;
+        artifact.lastStatAt = options.now ?? Date.now();
+      }
+      return;
+    }
+  }
+  getRealWorkspaceCwd() {
+    if (!this.realWorkspaceCwdPromise) {
+      const promise = fs2.realpath(this.workspaceCwd).catch((error) => {
+        if (this.realWorkspaceCwdPromise === promise) {
+          this.realWorkspaceCwdPromise = void 0;
+        }
+        throw error;
+      });
+      this.realWorkspaceCwdPromise = promise;
+    }
+    return this.realWorkspaceCwdPromise;
+  }
+  async evictOverflow(createdIds, changes) {
+    const removed = [];
+    if (this.artifacts.size <= this.maxArtifacts) {
+      return removed;
+    }
+    const createdInThisBatch = new Set(createdIds);
+    const candidates = Array.from(this.artifacts.values()).filter(
+      (artifact) => !createdInThisBatch.has(artifact.id)
+    );
+    const now = Date.now();
+    const staleWorkspaceCandidates = candidates.filter((artifact) => artifact.workspacePath).filter((artifact) => shouldRefreshWorkspaceStatus(artifact, now));
+    await runInBatches(
+      staleWorkspaceCandidates,
+      WORKSPACE_STATUS_REFRESH_BATCH_SIZE,
+      (artifact) => this.refreshWorkspaceStatus(artifact, { onError: "preserve", now })
+    );
+    const sourceCounts = countByRetentionSource(this.artifacts.values());
+    while (this.artifacts.size > this.maxArtifacts) {
+      const artifact = selectEvictionCandidate(candidates, sourceCounts);
+      if (!artifact) break;
+      this.artifacts.delete(artifact.id);
+      candidates.splice(candidates.indexOf(artifact), 1);
+      sourceCounts[artifact.retentionSource]--;
+      removePriorChange(changes, artifact.id);
+      removed.push({
+        action: "removed",
+        artifactId: artifact.id,
+        artifact: toPublicArtifact(artifact),
+        reason: "eviction"
+      });
+    }
+    const overflowCreated = Array.from(this.artifacts.values()).filter((artifact) => createdInThisBatch.has(artifact.id)).sort((a, b) => b.receivedSeq - a.receivedSeq);
+    for (const artifact of overflowCreated) {
+      if (this.artifacts.size <= this.maxArtifacts) {
+        break;
+      }
+      this.artifacts.delete(artifact.id);
+      writeStderrLine(
+        `[artifacts] session=${this.sessionId} action=dropped reason="max artifacts exceeded" artifactId=${artifact.id}`
+      );
+      removePriorChange(changes, artifact.id);
+    }
+    return removed;
+  }
+};
+function coalesceByIdentity(artifacts) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const artifact of artifacts) {
+    const existing = byId.get(artifact.id);
+    if (!existing) {
+      byId.set(artifact.id, artifact);
+      continue;
+    }
+    byId.set(artifact.id, mergeBatchArtifact(existing, artifact));
+  }
+  return Array.from(byId.values()).sort(
+    (a, b) => a.receivedSeq - b.receivedSeq
+  );
+}
+__name(coalesceByIdentity, "coalesceByIdentity");
+function mergeBatchArtifact(existing, next) {
+  const publishedUpgrade = existing.storage !== "published" && next.storage === "published" && next.trustedPublisher;
+  if (publishedUpgrade) {
+    const merged = {
+      ...existing,
+      id: next.id,
+      identityKey: next.identityKey,
+      kind: next.kind,
+      storage: "published",
+      status: next.status,
+      title: next.title,
+      description: next.description,
+      managedId: next.managedId ?? existing.managedId,
+      url: next.url ?? existing.url,
+      mimeType: next.mimeType ?? existing.mimeType,
+      sizeBytes: next.sizeBytes ?? existing.sizeBytes,
+      metadata: mergeMetadata(existing, next),
+      trustedPublisher: true,
+      createdAt: existing.createdAt,
+      receivedSeq: existing.receivedSeq,
+      retentionSource: existing.retentionSource,
+      clientRetained: existing.clientRetained || next.clientRetained,
+      lastStatAt: void 0
+    };
+    delete merged.workspacePath;
+    return merged;
+  }
+  return {
+    ...existing,
+    status: next.status,
+    sizeBytes: mergeSizeBytes(existing, next),
+    metadata: mergeMetadata(existing, next),
+    clientRetained: existing.clientRetained || next.clientRetained,
+    trustedPublisher: existing.trustedPublisher || next.trustedPublisher,
+    lastStatAt: next.lastStatAt ?? existing.lastStatAt
+  };
+}
+__name(mergeBatchArtifact, "mergeBatchArtifact");
+function mergeArtifact(existing, incoming) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const publishedUpgrade = existing.storage !== "published" && incoming.storage === "published" && incoming.trustedPublisher;
+  const publishedRefresh = existing.storage === "published" && incoming.storage === "published" && incoming.trustedPublisher && incoming.managedId !== void 0 && incoming.managedId === existing.managedId;
+  const publishedUpdate = publishedUpgrade || publishedRefresh;
+  const next = {
+    ...existing,
+    id: publishedUpdate ? incoming.id : existing.id,
+    identityKey: publishedUpdate ? incoming.identityKey : existing.identityKey,
+    kind: publishedUpdate ? incoming.kind : existing.kind,
+    storage: publishedUpgrade ? "published" : existing.storage,
+    status: existing.storage === "published" && !publishedUpdate ? existing.status : incoming.status,
+    managedId: publishedUpdate ? incoming.managedId ?? existing.managedId : existing.managedId,
+    url: publishedUpdate ? incoming.url ?? existing.url : existing.url,
+    workspacePath: publishedUpdate || existing.storage === "published" ? void 0 : existing.workspacePath ?? incoming.workspacePath,
+    mimeType: publishedUpdate ? incoming.mimeType ?? existing.mimeType : existing.mimeType,
+    sizeBytes: existing.storage === "published" && !publishedUpdate ? existing.sizeBytes : mergeSizeBytes(existing, incoming),
+    metadata: existing.storage === "published" && !publishedUpdate ? existing.metadata : mergeMetadata(existing, incoming),
+    source: existing.source,
+    retentionSource: existing.retentionSource,
+    trustedPublisher: existing.trustedPublisher || incoming.trustedPublisher,
+    clientRetained: existing.clientRetained || incoming.clientRetained,
+    lastStatAt: publishedUpdate || existing.storage === "published" ? void 0 : incoming.lastStatAt ?? existing.lastStatAt,
+    updatedAt: existing.updatedAt
+  };
+  if (publishedUpdate) {
+    next.title = incoming.title;
+    next.description = incoming.description;
+    delete next.workspacePath;
+  }
+  const changed = !publicArtifactsEqual(
+    toPublicArtifact(existing),
+    toPublicArtifact(next)
+  );
+  if (changed) {
+    next.updatedAt = now;
+  }
+  return { artifact: changed ? next : existing, changed };
+}
+__name(mergeArtifact, "mergeArtifact");
+function publicArtifactsEqual(a, b) {
+  return a.id === b.id && a.kind === b.kind && a.storage === b.storage && a.source === b.source && a.status === b.status && a.title === b.title && a.description === b.description && a.workspacePath === b.workspacePath && a.managedId === b.managedId && a.url === b.url && a.mimeType === b.mimeType && a.sizeBytes === b.sizeBytes && metadataEqual(a.metadata, b.metadata) && a.clientRetained === b.clientRetained && a.createdAt === b.createdAt && a.toolCallId === b.toolCallId && a.toolName === b.toolName && a.hookEventName === b.hookEventName && a.clientId === b.clientId;
+}
+__name(publicArtifactsEqual, "publicArtifactsEqual");
+function metadataEqual(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length) return false;
+  return aKeys.every((key) => Object.hasOwn(b, key) && a[key] === b[key]);
+}
+__name(metadataEqual, "metadataEqual");
+function mergeSizeBytes(existing, incoming) {
+  if (incoming.sizeBytes !== void 0) {
+    return incoming.sizeBytes;
+  }
+  if (incoming.workspacePath && incoming.status === "missing") {
+    return void 0;
+  }
+  return existing.sizeBytes;
+}
+__name(mergeSizeBytes, "mergeSizeBytes");
+function mergeMetadata(existing, incoming) {
+  if (!incoming.metadata || incoming.source === "hook" || incoming.source !== existing.source) {
+    return existing.metadata;
+  }
+  const merged = { ...existing.metadata ?? {} };
+  let changed = false;
+  for (const [key, value] of Object.entries(incoming.metadata)) {
+    if (!Object.hasOwn(merged, key)) {
+      merged[key] = value;
+      changed = true;
+    }
+  }
+  if (!changed) {
+    return existing.metadata;
+  }
+  if (!isMetadataWithinLimit(merged)) {
+    writeStderrLine(
+      `[artifacts] action=metadata_merge_dropped artifactId=${incoming.id} reason="metadata limit exceeded"`
+    );
+    return existing.metadata;
+  }
+  return merged;
+}
+__name(mergeMetadata, "mergeMetadata");
+function isMetadataWithinLimit(metadata) {
+  return Buffer.byteLength(JSON.stringify(metadata), "utf8") <= 4096;
+}
+__name(isMetadataWithinLimit, "isMetadataWithinLimit");
+function countByRetentionSource(artifacts) {
+  const counts = {
+    tool: 0,
+    client: 0,
+    hook: 0
+  };
+  for (const artifact of artifacts) {
+    counts[artifact.retentionSource]++;
+  }
+  return counts;
+}
+__name(countByRetentionSource, "countByRetentionSource");
+function shouldRefreshWorkspaceStatus(artifact, now) {
+  return artifact.lastStatAt === void 0 || now - artifact.lastStatAt >= WORKSPACE_STATUS_REFRESH_TTL_MS;
+}
+__name(shouldRefreshWorkspaceStatus, "shouldRefreshWorkspaceStatus");
+function selectEvictionCandidate(candidates, sourceCounts) {
+  return oldest(
+    candidates,
+    (artifact) => artifact.status === "missing" && !artifact.clientRetained
+  ) ?? oldest(
+    candidates,
+    (artifact) => !artifact.clientRetained && sourceCounts[artifact.retentionSource] > SOURCE_RESERVATIONS[artifact.retentionSource]
+  ) ?? oldest(candidates, (artifact) => !artifact.clientRetained) ?? oldest(candidates);
+}
+__name(selectEvictionCandidate, "selectEvictionCandidate");
+function oldest(artifacts, predicate = () => true) {
+  let selected;
+  for (const artifact of artifacts) {
+    if (!predicate(artifact)) {
+      continue;
+    }
+    if (!selected || compareOldest(artifact, selected) < 0) {
+      selected = artifact;
+    }
+  }
+  return selected;
+}
+__name(oldest, "oldest");
+function compareOldest(a, b) {
+  const created = a.createdAt.localeCompare(b.createdAt);
+  if (created !== 0) return created;
+  return a.insertSeq - b.insertSeq;
+}
+__name(compareOldest, "compareOldest");
+function removePriorChange(changes, artifactId) {
+  const index = changes.findIndex((change) => change.artifactId === artifactId);
+  if (index >= 0) {
+    changes.splice(index, 1);
+  }
+}
+__name(removePriorChange, "removePriorChange");
+function toPublicArtifact(artifact) {
+  const {
+    id,
+    kind,
+    storage,
+    source,
+    status,
+    title,
+    description,
+    workspacePath,
+    managedId,
+    url,
+    mimeType,
+    sizeBytes,
+    metadata,
+    clientRetained,
+    createdAt,
+    updatedAt,
+    toolCallId,
+    toolName,
+    hookEventName,
+    clientId
+  } = artifact;
+  return {
+    id,
+    kind,
+    storage,
+    source,
+    status,
+    title,
+    ...description ? { description } : {},
+    ...workspacePath ? { workspacePath } : {},
+    ...managedId ? { managedId } : {},
+    ...url ? { url } : {},
+    ...mimeType ? { mimeType } : {},
+    ...sizeBytes !== void 0 ? { sizeBytes } : {},
+    ...metadata ? { metadata } : {},
+    clientRetained,
+    createdAt,
+    updatedAt,
+    ...toolCallId ? { toolCallId } : {},
+    ...toolName ? { toolName } : {},
+    ...hookEventName ? { hookEventName } : {},
+    ...clientId ? { clientId } : {}
+  };
+}
+__name(toPublicArtifact, "toPublicArtifact");
+function inferStorage(requested, locators) {
+  if (requested !== void 0 && typeof requested !== "string") {
+    throw new SessionArtifactValidationError(
+      "storage must be a string",
+      "storage"
+    );
+  }
+  if (requested) {
+    if (requested !== "workspace" && requested !== "external_url" && requested !== "managed" && requested !== "published") {
+      throw new SessionArtifactValidationError(
+        "storage must be workspace, external_url, managed, or published",
+        "storage"
+      );
+    }
+    return requested;
+  }
+  if (locators.workspacePath) return "workspace";
+  if (locators.managedId) return "managed";
+  if (locators.url && locators.trustedPublisher) return "published";
+  return "external_url";
+}
+__name(inferStorage, "inferStorage");
+function normalizeKind(kind) {
+  if (kind === "file" || kind === "link" || kind === "html" || kind === "image" || kind === "video" || kind === "audio" || kind === "pdf" || kind === "notebook" || kind === "other") {
+    return kind;
+  }
+  throw new SessionArtifactValidationError(
+    "kind must be a supported artifact kind",
+    "kind"
+  );
+}
+__name(normalizeKind, "normalizeKind");
+function validateLocator(storage, locators) {
+  if (storage === "published") {
+    if (!locators.trustedPublisher) {
+      throw new SessionArtifactValidationError(
+        "published artifacts are reserved for trusted publishers",
+        "storage"
+      );
+    }
+    if (!locators.url) {
+      throw new SessionArtifactValidationError(
+        "published artifacts require url",
+        "url"
+      );
+    }
+    if (locators.workspacePath) {
+      throw new SessionArtifactValidationError(
+        "published artifacts cannot include workspacePath",
+        "workspacePath"
+      );
+    }
+    return;
+  }
+  const locatorCount = [
+    locators.workspacePath,
+    locators.managedId,
+    locators.url
+  ].filter(Boolean).length;
+  if (locatorCount !== 1) {
+    throw new SessionArtifactValidationError(
+      "provide exactly one of workspacePath, managedId, or url"
+    );
+  }
+  if (storage === "workspace" && !locators.workspacePath) {
+    throw new SessionArtifactValidationError(
+      "workspace storage requires workspacePath",
+      "workspacePath"
+    );
+  }
+  if (storage === "managed" && !locators.managedId) {
+    throw new SessionArtifactValidationError(
+      "managed storage requires managedId",
+      "managedId"
+    );
+  }
+  if (storage === "external_url" && !locators.url) {
+    throw new SessionArtifactValidationError(
+      "external_url storage requires url",
+      "url"
+    );
+  }
+}
+__name(validateLocator, "validateLocator");
+function buildIdentityKey(input) {
+  if (input.workspacePath) return `workspace:${input.workspacePath}`;
+  if (input.managedId) return `managed:${input.managedId}`;
+  if (input.url) return `url:${input.url}`;
+  throw new SessionArtifactValidationError(
+    "artifact identity requires workspacePath, managedId, or url"
+  );
+}
+__name(buildIdentityKey, "buildIdentityKey");
+function stableArtifactId(sessionId, identityKey) {
+  return createHash("sha256").update(`${sessionId}:${identityKey}`).digest("hex").slice(0, 16);
+}
+__name(stableArtifactId, "stableArtifactId");
+function managedIdForWorkspacePath(workspaceCwd, workspacePath) {
+  return createHash("sha1").update(path2.resolve(workspaceCwd, workspacePath)).digest("hex").slice(0, 16);
+}
+__name(managedIdForWorkspacePath, "managedIdForWorkspacePath");
+function normalizeString(value, field, maxLength, required) {
+  if (value === void 0 || value === null) {
+    if (required) {
+      throw new SessionArtifactValidationError(`${field} is required`, field);
+    }
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new SessionArtifactValidationError(
+      `${field} must be a string`,
+      field
+    );
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    if (required) {
+      throw new SessionArtifactValidationError(`${field} is required`, field);
+    }
+    return void 0;
+  }
+  if (trimmed.length > maxLength) {
+    throw new SessionArtifactValidationError(
+      `${field} exceeds ${maxLength} characters`,
+      field
+    );
+  }
+  if (hasControlCharacter(trimmed, field === "description")) {
+    throw new SessionArtifactValidationError(
+      `${field} contains control characters`,
+      field
+    );
+  }
+  if (isDisplayField(field) && hasUnsafeDisplayPayload(trimmed)) {
+    throw new SessionArtifactValidationError(
+      `${field} contains unsafe markup`,
+      field
+    );
+  }
+  return trimmed;
+}
+__name(normalizeString, "normalizeString");
+function normalizeManagedId(value) {
+  const managedId = normalizeString(value, "managedId", 200, false);
+  if (!managedId) return void 0;
+  if (managedId.includes("/") || managedId.includes("\\") || managedId.includes("..") || path2.isAbsolute(managedId) || path2.win32.isAbsolute(managedId)) {
+    throw new SessionArtifactValidationError(
+      "managedId must be an opaque managed resource id",
+      "managedId"
+    );
+  }
+  return managedId;
+}
+__name(normalizeManagedId, "normalizeManagedId");
+function isDisplayField(field) {
+  return field === "title" || field === "description" || field === "mimeType" || field === "workspacePath" || field === "managedId";
+}
+__name(isDisplayField, "isDisplayField");
+function hasControlCharacter(value, allowLineWhitespace = false) {
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (allowLineWhitespace && (code === 9 || code === 10 || code === 13)) {
+      continue;
+    }
+    if (code <= 31 || code === 127 || code >= 8203 && code <= 8207 || code === 8232 || code === 8233 || code >= 8234 && code <= 8238 || code >= 8294 && code <= 8297 || code === 65279) {
+      return true;
+    }
+  }
+  return false;
+}
+__name(hasControlCharacter, "hasControlCharacter");
+function hasUnsafeDisplayPayload(value) {
+  return /<\s*\/?[a-z!]|&(?:#[0-9]+|#x[0-9a-f]+|[a-z][a-z0-9]+);|javascript\s*:|data\s*:\s*(?:text\/(?:html|javascript)|application\/javascript|image\/svg\+xml)/i.test(
+    value
+  ) || /(?:^|[\s"'`<])on[a-z][a-z0-9-]*\s*=/i.test(value);
+}
+__name(hasUnsafeDisplayPayload, "hasUnsafeDisplayPayload");
+function normalizeWorkspacePath(raw, workspaceCwd) {
+  const trimmed = normalizeString(raw, "workspacePath", 500, true);
+  if (path2.isAbsolute(trimmed)) {
+    throw new SessionArtifactValidationError(
+      "workspacePath must be relative to the workspace",
+      "workspacePath"
+    );
+  }
+  const absolute = path2.resolve(workspaceCwd, trimmed);
+  const relative = path2.relative(workspaceCwd, absolute);
+  if (!relative || isOutsidePath(relative)) {
+    throw new SessionArtifactValidationError(
+      "workspacePath must stay inside the workspace",
+      "workspacePath"
+    );
+  }
+  return relative.split(path2.sep).join("/");
+}
+__name(normalizeWorkspacePath, "normalizeWorkspacePath");
+function normalizeArtifactUrl(raw, allowFile) {
+  const trimmed = normalizeString(raw, "url", 2048, true);
+  let parsed;
+  try {
+    parsed = new URL(trimmed);
+  } catch {
+    throw new SessionArtifactValidationError("url must be valid", "url");
+  }
+  if (parsed.username || parsed.password) {
+    throw new SessionArtifactValidationError(
+      "url must not include credentials",
+      "url"
+    );
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:" && !(allowFile && parsed.protocol === "file:")) {
+    throw new SessionArtifactValidationError(
+      allowFile ? "url must use http, https, or file" : "url must use http or https",
+      "url"
+    );
+  }
+  return parsed.href;
+}
+__name(normalizeArtifactUrl, "normalizeArtifactUrl");
+function normalizeMetadata(metadata) {
+  if (metadata === void 0) {
+    return void 0;
+  }
+  if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata)) {
+    throw new SessionArtifactValidationError(
+      "metadata must be an object",
+      "metadata"
+    );
+  }
+  const normalized = {};
+  for (const [key, value] of Object.entries(metadata)) {
+    if (!key) {
+      throw new SessionArtifactValidationError(
+        "metadata keys must not be empty",
+        "metadata"
+      );
+    }
+    if (key.length > 120) {
+      throw new SessionArtifactValidationError(
+        "metadata keys must be 120 characters or fewer",
+        "metadata"
+      );
+    }
+    if (hasControlCharacter(key) || hasUnsafeDisplayPayload(key)) {
+      throw new SessionArtifactValidationError(
+        "metadata keys contain unsafe content",
+        "metadata"
+      );
+    }
+    if (value !== null && typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+      throw new SessionArtifactValidationError(
+        "metadata values must be primitive",
+        "metadata"
+      );
+    }
+    if (typeof value === "number" && !Number.isFinite(value)) {
+      throw new SessionArtifactValidationError(
+        "metadata numbers must be finite",
+        "metadata"
+      );
+    }
+    if (typeof value === "string" && (hasControlCharacter(value) || hasUnsafeDisplayPayload(value))) {
+      throw new SessionArtifactValidationError(
+        "metadata string values contain unsafe content",
+        "metadata"
+      );
+    }
+    normalized[key] = value;
+  }
+  if (Object.keys(normalized).length === 0) {
+    return void 0;
+  }
+  if (Buffer.byteLength(JSON.stringify(normalized), "utf8") > 4096) {
+    throw new SessionArtifactValidationError(
+      "metadata must be 4096 bytes or fewer",
+      "metadata"
+    );
+  }
+  return normalized;
+}
+__name(normalizeMetadata, "normalizeMetadata");
+function normalizeSizeBytes(value) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    throw new SessionArtifactValidationError(
+      "sizeBytes must be a non-negative safe integer",
+      "sizeBytes"
+    );
+  }
+  return value;
+}
+__name(normalizeSizeBytes, "normalizeSizeBytes");
+function inferKind(input) {
+  if (input.storage === "published") return "html";
+  if (input.url) return "link";
+  const ext = input.workspacePath ? path2.extname(input.workspacePath).toLowerCase() : "";
+  if (ext === ".html" || ext === ".htm") return "html";
+  if ([".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg"].includes(ext)) {
+    return "image";
+  }
+  if ([".mp4", ".mov", ".webm"].includes(ext)) return "video";
+  if ([".mp3", ".wav", ".m4a", ".ogg"].includes(ext)) return "audio";
+  if (ext === ".pdf") return "pdf";
+  if (ext === ".ipynb") return "notebook";
+  return input.workspacePath ? "file" : "other";
+}
+__name(inferKind, "inferKind");
+async function getWorkspaceStatus(workspaceCwd, workspacePath, realWorkspaceCwd) {
+  const absolutePath = path2.resolve(workspaceCwd, workspacePath);
+  const realWorkspace = await realWorkspaceCwd;
+  try {
+    const realPath = await fs2.realpath(absolutePath);
+    const relative = path2.relative(realWorkspace, realPath);
+    if (!relative || isOutsidePath(relative)) {
+      return { status: "missing", escaped: true };
+    }
+    const stat = await fs2.stat(realPath);
+    return {
+      status: "available",
+      ...stat.isFile() ? { sizeBytes: stat.size } : {}
+    };
+  } catch (error) {
+    if (!isNotFoundError(error)) {
+      throw error;
+    }
+    if (await danglingSymlinkEscapesWorkspace(absolutePath, realWorkspace)) {
+      return { status: "missing", escaped: true };
+    }
+    return { status: "missing" };
+  }
+}
+__name(getWorkspaceStatus, "getWorkspaceStatus");
+async function danglingSymlinkEscapesWorkspace(absolutePath, realWorkspace) {
+  try {
+    const stat = await fs2.lstat(absolutePath);
+    if (!stat.isSymbolicLink()) {
+      return false;
+    }
+    const target = await fs2.readlink(absolutePath);
+    const parent = await fs2.realpath(path2.dirname(absolutePath));
+    const targetPath = path2.resolve(parent, target);
+    return isOutsidePath(path2.relative(realWorkspace, targetPath));
+  } catch (error) {
+    if (isNotFoundError(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+__name(danglingSymlinkEscapesWorkspace, "danglingSymlinkEscapesWorkspace");
+async function runInBatches(items, batchSize, fn) {
+  for (let index = 0; index < items.length; index += batchSize) {
+    await Promise.all(items.slice(index, index + batchSize).map(fn));
+  }
+}
+__name(runInBatches, "runInBatches");
+function isNotFoundError(error) {
+  if (typeof error !== "object" || error === null || !("code" in error)) {
+    return false;
+  }
+  const code = error.code;
+  return code === "ENOENT" || code === "ENOTDIR";
+}
+__name(isNotFoundError, "isNotFoundError");
+function isOutsidePath(relative) {
+  return relative === ".." || relative.startsWith(`..${path2.sep}`) || path2.isAbsolute(relative);
+}
+__name(isOutsidePath, "isOutsidePath");
+
 // packages/acp-bridge/src/bridge.ts
 var NOOP_BRIDGE_TELEMETRY = {
   captureContext: /* @__PURE__ */ __name(() => void 0, "captureContext"),
@@ -1927,6 +3111,62 @@ function parseWorkspaceMemoryRememberResult(response) {
   };
 }
 __name(parseWorkspaceMemoryRememberResult, "parseWorkspaceMemoryRememberResult");
+function isBridgeAutoMemoryTopic(value) {
+  return value === "user" || value === "feedback" || value === "project" || value === "reference";
+}
+__name(isBridgeAutoMemoryTopic, "isBridgeAutoMemoryTopic");
+function parseWorkspaceMemoryForgetMatch(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  const record = value;
+  if (!isBridgeAutoMemoryTopic(record["topic"]) || typeof record["summary"] !== "string" || typeof record["filePath"] !== "string") {
+    return null;
+  }
+  return {
+    topic: record["topic"],
+    summary: record["summary"],
+    filePath: record["filePath"]
+  };
+}
+__name(parseWorkspaceMemoryForgetMatch, "parseWorkspaceMemoryForgetMatch");
+function parseWorkspaceMemoryForgetResult(response) {
+  if (response === null || typeof response !== "object" || Array.isArray(response)) {
+    throw new Error("Malformed workspace memory forget response");
+  }
+  const record = response;
+  const summary = record["summary"];
+  const removedEntries = record["removedEntries"];
+  const touchedTopics = record["touchedTopics"];
+  const parsedRemovedEntries = Array.isArray(removedEntries) ? removedEntries.map(parseWorkspaceMemoryForgetMatch) : [];
+  if (summary !== void 0 && typeof summary !== "string" || !Array.isArray(removedEntries) || parsedRemovedEntries.some((entry) => entry === null) || !Array.isArray(touchedTopics) || !touchedTopics.every(isBridgeAutoMemoryTopic)) {
+    throw new Error("Malformed workspace memory forget response");
+  }
+  return {
+    ...summary === void 0 ? {} : { summary },
+    removedEntries: parsedRemovedEntries,
+    touchedTopics
+  };
+}
+__name(parseWorkspaceMemoryForgetResult, "parseWorkspaceMemoryForgetResult");
+function parseWorkspaceMemoryDreamResult(response) {
+  if (response === null || typeof response !== "object" || Array.isArray(response)) {
+    throw new Error("Malformed workspace memory dream response");
+  }
+  const record = response;
+  const summary = record["summary"];
+  const touchedTopics = record["touchedTopics"];
+  const dedupedEntries = record["dedupedEntries"];
+  if (summary !== void 0 && typeof summary !== "string" || !Array.isArray(touchedTopics) || !touchedTopics.every(isBridgeAutoMemoryTopic) || typeof dedupedEntries !== "number" || !Number.isFinite(dedupedEntries)) {
+    throw new Error("Malformed workspace memory dream response");
+  }
+  return {
+    ...summary === void 0 ? {} : { summary },
+    touchedTopics,
+    dedupedEntries
+  };
+}
+__name(parseWorkspaceMemoryDreamResult, "parseWorkspaceMemoryDreamResult");
 function echoPromptToSessionBus(entry, req, originatorClientId) {
   const prompt = req.prompt;
   if (!Array.isArray(prompt) || prompt.length === 0) return;
@@ -2050,7 +3290,7 @@ function broadcastTurnError(entry, sessionId, err, promptId, originatorClientId)
   }
 }
 __name(broadcastTurnError, "broadcastTurnError");
-function hasControlCharacter(value) {
+function hasControlCharacter2(value) {
   for (let i = 0; i < value.length; i += 1) {
     const code = value.charCodeAt(i);
     if (code <= 31 || code === 127) {
@@ -2059,7 +3299,7 @@ function hasControlCharacter(value) {
   }
   return false;
 }
-__name(hasControlCharacter, "hasControlCharacter");
+__name(hasControlCharacter2, "hasControlCharacter");
 function extractPromptText(prompt) {
   if (!Array.isArray(prompt)) return "";
   let hasImage = false;
@@ -2152,7 +3392,7 @@ function createAcpSessionBridge(opts) {
   } else {
     maxPendingPromptsPerSession = maxPendingPromptsRaw;
   }
-  if (!path2.isAbsolute(opts.boundWorkspace)) {
+  if (!path3.isAbsolute(opts.boundWorkspace)) {
     throw new TypeError(
       `Invalid boundWorkspace: "${opts.boundWorkspace}". Must be an absolute path.`
     );
@@ -2378,6 +3618,7 @@ function createAcpSessionBridge(opts) {
         },
         async () => await channelFactory(boundWorkspace, childEnvOverrides)
       );
+      const sessionIds = /* @__PURE__ */ new Set();
       const client = new BridgeClient(
         // BfFut: ACP today carries a sessionId on every per-session
         // notification / request, so the no-sessionId branch is
@@ -2427,14 +3668,15 @@ function createAcpSessionBridge(opts) {
         // the per-WS-connection `ClientMcpRegistrar`. Omitted callers (tests,
         // Mode A) never host a client MCP server, so the method stays
         // unreachable.
-        opts.clientMcpSender
+        opts.clientMcpSender,
+        (sessionId) => sessionIds.has(sessionId)
       );
       const connection = new ClientSideConnection(() => client, channel.stream);
       const info = {
         channel,
         connection,
         client,
-        sessionIds: /* @__PURE__ */ new Set(),
+        sessionIds,
         pendingRestoreIds: /* @__PURE__ */ new Set(),
         sessionSpawnsInFlight: 0,
         workspaceControlInFlight: 0,
@@ -2685,7 +3927,7 @@ function createAcpSessionBridge(opts) {
     return entry.transportClosedReject;
   }, "getTransportClosedReject");
   const resolveWorkspaceKey = /* @__PURE__ */ __name((workspaceCwd) => {
-    if (!path2.isAbsolute(workspaceCwd)) {
+    if (!path3.isAbsolute(workspaceCwd)) {
       throw new Error(
         `workspaceCwd must be an absolute path; got "${workspaceCwd}"`
       );
@@ -2910,6 +4152,7 @@ function createAcpSessionBridge(opts) {
       channel: ci.channel,
       connection: ci.connection,
       events,
+      artifacts: new SessionArtifactStore({ sessionId, workspaceCwd }),
       promptQueue: Promise.resolve(),
       pendingPromptCount: 0,
       pendingPromptList: [],
@@ -2933,6 +4176,34 @@ function createAcpSessionBridge(opts) {
     ci.client.drainEarlyEvents(entry.sessionId, entry);
     return entry;
   }, "createSessionEntry");
+  const publishArtifactChanges = /* @__PURE__ */ __name((entry, changes, originatorClientId) => {
+    for (const change of changes) {
+      entry.events.publish({
+        type: "artifact_changed",
+        data: { sessionId: entry.sessionId, change },
+        ...originatorClientId ? { originatorClientId } : {}
+      });
+    }
+  }, "publishArtifactChanges");
+  const makeClientArtifactInput = /* @__PURE__ */ __name((artifact, clientId) => {
+    const input = {
+      title: artifact.title,
+      kind: artifact.kind,
+      storage: artifact.storage,
+      description: artifact.description,
+      workspacePath: artifact.workspacePath,
+      managedId: artifact.managedId,
+      url: artifact.url,
+      mimeType: artifact.mimeType,
+      sizeBytes: artifact.sizeBytes,
+      metadata: artifact.metadata,
+      source: "client"
+    };
+    if (clientId) {
+      input.clientId = clientId;
+    }
+    return input;
+  }, "makeClientArtifactInput");
   const seedSnapshotCaches = /* @__PURE__ */ __name((entry, resp) => {
     const model = resp.models?.currentModelId;
     if (typeof model === "string" && model.length > 0) {
@@ -3957,7 +5228,7 @@ function createAcpSessionBridge(opts) {
             `must be a string of at most ${MAX_DISPLAY_NAME_LENGTH} characters`
           );
         }
-        if (hasControlCharacter(metadata.displayName)) {
+        if (hasControlCharacter2(metadata.displayName)) {
           throw new InvalidSessionMetadataError(
             "displayName",
             "must not contain control characters"
@@ -3999,8 +5270,30 @@ function createAcpSessionBridge(opts) {
       }
       return { displayName: entry.displayName };
     },
+    async getSessionArtifacts(sessionId) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      return entry.artifacts.list();
+    },
+    async addSessionArtifact(sessionId, artifact, context) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      const clientId = resolveTrustedClientId(entry, context?.clientId);
+      const input = makeClientArtifactInput(artifact, clientId);
+      const result = await entry.artifacts.upsertMany([input], { strict: true });
+      publishArtifactChanges(entry, result.changes, clientId);
+      return result;
+    },
+    async removeSessionArtifact(sessionId, artifactId, context) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      const clientId = resolveTrustedClientId(entry, context?.clientId);
+      const result = await entry.artifacts.remove(artifactId, { clientId });
+      publishArtifactChanges(entry, result.changes, clientId);
+      return result;
+    },
     listWorkspaceSessions(workspaceCwd) {
-      if (!path2.isAbsolute(workspaceCwd)) return [];
+      if (!path3.isAbsolute(workspaceCwd)) return [];
       const key = workspaceCwd === boundWorkspace ? boundWorkspace : canonicalizeWorkspace(workspaceCwd);
       if (key !== boundWorkspace) return [];
       const out = [];
@@ -4142,6 +5435,54 @@ function createAcpSessionBridge(opts) {
         }
       }
     },
+    async runWorkspaceMemoryForget(request) {
+      const info = await ensureChannel();
+      try {
+        const response = await withWorkspaceControl(
+          info,
+          () => withTimeout(
+            Promise.race([
+              info.connection.extMethod(
+                SERVE_CONTROL_EXT_METHODS.workspaceMemoryForget,
+                { ...request, cwd: boundWorkspace }
+              ),
+              getChannelClosedReject(info)
+            ]),
+            WORKSPACE_MEMORY_REMEMBER_TIMEOUT_MS,
+            SERVE_CONTROL_EXT_METHODS.workspaceMemoryForget
+          )
+        );
+        return parseWorkspaceMemoryForgetResult(response);
+      } finally {
+        if (hasNoChannelWork(info)) {
+          await startIdleTimer(info, "workspace memory forget");
+        }
+      }
+    },
+    async runWorkspaceMemoryDream() {
+      const info = await ensureChannel();
+      try {
+        const response = await withWorkspaceControl(
+          info,
+          () => withTimeout(
+            Promise.race([
+              info.connection.extMethod(
+                SERVE_CONTROL_EXT_METHODS.workspaceMemoryDream,
+                { cwd: boundWorkspace }
+              ),
+              getChannelClosedReject(info)
+            ]),
+            WORKSPACE_MEMORY_REMEMBER_TIMEOUT_MS,
+            SERVE_CONTROL_EXT_METHODS.workspaceMemoryDream
+          )
+        );
+        return parseWorkspaceMemoryDreamResult(response);
+      } finally {
+        if (hasNoChannelWork(info)) {
+          await startIdleTimer(info, "workspace memory dream");
+        }
+      }
+    },
     async getWorkspaceMcpToolsStatus(serverName) {
       return requestWorkspaceStatus(
         SERVE_STATUS_EXT_METHODS.workspaceMcpTools,
@@ -5214,6 +6555,7 @@ __name(withTimeout, "withTimeout");
 var createHttpAcpBridge = createAcpSessionBridge;
 
 export {
+  SessionArtifactValidationError,
   extractErrorMessage,
   extractErrorCode,
   createAcpSessionBridge,
@@ -5224,3 +6566,8 @@ export {
  * Copyright 2025 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */