@qwen-code/qwen-code 0.22.2 → 0.22.3

package/chunks/{chunk-RIEFGNTP.js → chunk-734C6JGI.js}

@@ -11,7 +11,7 @@ import {
   isSessionAttachmentReference,
   withAttachmentDegradationMarker,
   writeStderrLine
-} from "./chunk-ZGXYO7DY.js";
+} from "./chunk-SS4MRMKE.js";
 import {
   DEFAULT_RING_SIZE,
   EVENT_SCHEMA_VERSION,
@@ -31,7 +31,7 @@ import {
 } from "./chunk-OCPBI7J5.js";
 import {
   defaultSpawnChannelFactory
-} from "./chunk-RUGNCYNO.js";
+} from "./chunk-DMLVSW7L.js";
 import {
   BridgeChannelClosedError,
   BridgeTimeoutError,
@@ -41,7 +41,7 @@ import {
   SessionRestoreTimeoutError,
   createIdleWorkspaceExtensionsStatus,
   createIdleWorkspaceHooksStatus
-} from "./chunk-JHS74YAB.js";
+} from "./chunk-KID24ZFN.js";
 import {
   ACTIVE_WORK_CLOSE_IF_UNHELD_PARAM,
   ACTIVE_WORK_CLOSE_TIMEOUT_MS,
@@ -120,9 +120,8 @@ import {
   isOfficeDocumentExtension,
   isRecordableDerivedChild,
   pathHasSkippedDirectoryComponent
-} from "./chunk-6IUNAPLR.js";
+} from "./chunk-K5KXUXWC.js";
 import {
-  SESSION_ARTIFACT_PERSISTENCE_VERSION,
   SESSION_PR_LIST_LIMIT,
   SESSION_PR_URL_MAX_LENGTH,
   SESSION_TRANSCRIPT_MAX_LIMIT,
@@ -130,24 +129,31 @@ import {
   TURN_RESULT_CODE_TEXT_TRUNCATED,
   TURN_RESULT_TEXT_MAX_CHARS,
   TrustGateError,
+  canonicalSessionPrUrl,
+  normalizeTurnResultError
+} from "./chunk-PZ66FRIC.js";
+import {
+  PUBLISHED_CONTENT_SHA256_METADATA_KEY,
+  SESSION_ARTIFACT_PERSISTENCE_VERSION,
   WORKSPACE_CONTENT_MTIME_MS_METADATA_KEY,
   WORKSPACE_CONTENT_SHA256_METADATA_KEY,
+  WORKSPACE_CONTENT_SIZE_BYTES_METADATA_KEY,
+  isAdoptableContentFingerprintKey,
   isPrototypeMetadataKey,
   isReservedWorkspaceMetadataKey,
   metadataBudgetBytes,
   normalizeSnapshotPayload,
-  normalizeTurnResultError,
   stableSessionArtifactId
-} from "./chunk-TGWAQ5RB.js";
+} from "./chunk-DJBQCO2E.js";
 import {
   DAEMON_TRACEPARENT_META_KEY,
   DAEMON_TRACESTATE_META_KEY
-} from "./chunk-HVEYF6VT.js";
+} from "./chunk-3WK3QDNV.js";
 import {
   INVOCATION_CONTEXT_META_KEY,
   PRIVATE_ACP_CAPABILITY_ENV,
   PRIVATE_PARENT_CAPABILITY_META_KEY
-} from "./chunk-L2M46FP5.js";
+} from "./chunk-QYMAKPY5.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -1498,7 +1504,10 @@ var GenerationStreamQueue = class {
 // packages/acp-bridge/src/sessionArtifacts.ts
 init_esbuild_shims();
 import { createHash } from "node:crypto";
-import { constants as fsConstants, promises as fs } from "node:fs";
+import {
+  constants as fsConstants,
+  promises as fs
+} from "node:fs";
 import path from "node:path";
 var SOURCE_RESERVATIONS = {
   tool: 100,
@@ -1581,6 +1590,7 @@ var SessionArtifactStore = class {
   async list() {
     return this.enqueue(async () => {
       await this.refreshWorkspaceStatuses();
+      await this.forgetVanishedAutoRecordedArtifacts();
       return {
         v: 1,
         sessionId: this.sessionId,
@@ -1596,9 +1606,14 @@ var SessionArtifactStore = class {
     return this.enqueue(async () => {
       const artifact = this.artifacts.get(artifactId);
       if (!artifact) return void 0;
-      if (artifact.workspacePath && shouldRefreshWorkspaceStatus(artifact, Date.now())) {
+      if (artifact.workspacePath && needsWorkspaceStatusRefresh(artifact, Date.now())) {
         await this.refreshWorkspaceStatus(artifact, { onError: "missing" });
       }
+      if (isVanishedAutoRecordedWorkspaceArtifact(artifact)) {
+        await this.forgetVanishedAutoRecordedArtifacts([artifact]);
+        const kept = this.artifacts.get(artifactId);
+        return kept ? toPublicArtifact(kept) : void 0;
+      }
       return toPublicArtifact(artifact);
     });
   }
@@ -1693,7 +1708,7 @@ var SessionArtifactStore = class {
               const removeChange = {
                 action: "removed",
                 artifactId: existing.id,
-                artifact: toPublicArtifact(existing),
+                artifact: toRemovedPublicArtifact(existing),
                 reason: "explicit",
                 durableTombstoneRequired: existing.durableTombstoneRequired || existing.persistedAt !== void 0,
                 removedClientId: existing.clientId
@@ -1704,7 +1719,7 @@ var SessionArtifactStore = class {
               changes.push({
                 action: "removed",
                 artifactId: existing.id,
-                artifact: toPublicArtifact(existing),
+                artifact: toRemovedPublicArtifact(existing),
                 reason: "unpin_to_ephemeral",
                 durableTombstoneRequired: true
               });
@@ -1836,10 +1851,11 @@ var SessionArtifactStore = class {
         return { v: 1, sessionId: this.sessionId, changes: [] };
       }
       this.denyCrossClientMutation("remove", artifactId, existing, options);
+      const removedAt = (/* @__PURE__ */ new Date()).toISOString();
       const removeChange = {
         action: "removed",
         artifactId,
-        artifact: toPublicArtifact(existing),
+        artifact: toRemovedPublicArtifact(existing, removedAt),
         reason: "explicit",
         durableTombstoneRequired: existing.durableTombstoneRequired || existing.retention !== "ephemeral" ? true : void 0,
         removedClientId: existing.clientId
@@ -2634,7 +2650,8 @@ var SessionArtifactStore = class {
     }
     const metadata = withWorkspaceContentHashMetadata(
       normalizeMetadata(input.metadata, {
-        budget: options.metadataBudget ?? "user"
+        budget: options.metadataBudget ?? "user",
+        trustedPublisher
       }),
       workspaceStatus
     );
@@ -2698,7 +2715,7 @@ var SessionArtifactStore = class {
   }
   async refreshWorkspaceStatuses() {
     const now = Date.now();
-    const staleWorkspaceArtifacts = Array.from(this.artifacts.values()).filter((artifact) => artifact.workspacePath).filter((artifact) => shouldRefreshWorkspaceStatus(artifact, now));
+    const staleWorkspaceArtifacts = Array.from(this.artifacts.values()).filter((artifact) => artifact.workspacePath).filter((artifact) => needsWorkspaceStatusRefresh(artifact, now));
     await runInBatches(
       staleWorkspaceArtifacts,
       WORKSPACE_STATUS_REFRESH_BATCH_SIZE,
@@ -2739,27 +2756,55 @@ var SessionArtifactStore = class {
     if (!artifact.workspacePath) {
       return;
     }
+    const previousStatus = artifact.status;
+    const previousSizeBytes = artifact.sizeBytes;
     try {
       const status = await getWorkspaceStatus(
         artifact.workspacePath,
         this.getRealWorkspaceCwd(),
         {
-          sizeBytes: artifact.sizeBytes,
+          sizeBytes: recordedWorkspaceSizeBytes(artifact),
           mtimeMs: artifact.metadata?.[WORKSPACE_CONTENT_MTIME_MS_METADATA_KEY],
           sha256: artifact.metadata?.[WORKSPACE_CONTENT_SHA256_METADATA_KEY]
         }
       );
-      const changed = isWorkspaceContentChanged(artifact, status);
-      artifact.status = changed ? "changed" : status.status;
-      if (!changed) {
-        artifact.sizeBytes = status.sizeBytes;
-      }
+      const contentChanged = isWorkspaceContentChanged(artifact, status);
+      artifact.status = contentChanged ? "changed" : status.status;
+      artifact.missingFromStatError = void 0;
       if (status.escaped) {
         artifact.status = "missing";
         artifact.sizeBytes = void 0;
         artifact.hideWorkspacePath = true;
+      } else if (status.status === "missing") {
+        artifact.sizeBytes = void 0;
+      } else if (status.sizeBytes !== void 0) {
+        if (artifact.status === "changed" && artifact.metadata?.[WORKSPACE_CONTENT_SIZE_BYTES_METADATA_KEY] === void 0) {
+          const baseline = recordedWorkspaceSizeBytes(artifact);
+          if (baseline !== void 0) {
+            artifact.metadata = {
+              ...artifact.metadata,
+              [WORKSPACE_CONTENT_SIZE_BYTES_METADATA_KEY]: baseline
+            };
+          }
+        }
+        artifact.sizeBytes = status.sizeBytes;
+      }
+      if (artifact.status === "available" && !status.escaped) {
+        artifact.metadata = withWorkspaceContentHashMetadata(
+          artifact.metadata,
+          {
+            status: "available",
+            sha256: status.sha256,
+            mtimeMs: status.mtimeMs,
+            sizeBytes: status.sizeBytes
+          }
+        );
       }
       artifact.lastStatAt = options.now ?? Date.now();
+      const observationChanged = !status.escaped && status.status !== "missing" && recordWorkspaceObservation(artifact, status);
+      if (artifact.status !== previousStatus || artifact.sizeBytes !== previousSizeBytes || observationChanged) {
+        artifact.updatedAt = new Date(artifact.lastStatAt).toISOString();
+      }
     } catch (error) {
       writeStderrLine(
         `[artifacts] session=${this.sessionId} action=status_refresh_failed artifactId=${artifact.id} reason=${JSON.stringify(
@@ -2769,11 +2814,53 @@ var SessionArtifactStore = class {
       if (options.onError === "missing") {
         artifact.status = "missing";
         artifact.sizeBytes = void 0;
+        artifact.missingFromStatError = true;
         artifact.lastStatAt = options.now ?? Date.now();
+        if (previousStatus !== "missing" || previousSizeBytes !== void 0) {
+          artifact.updatedAt = new Date(artifact.lastStatAt).toISOString();
+        }
       }
       return;
     }
   }
+  async forgetVanishedAutoRecordedArtifacts(candidates) {
+    const vanished = (candidates ?? Array.from(this.artifacts.values())).filter(
+      isVanishedAutoRecordedWorkspaceArtifact
+    );
+    if (vanished.length === 0) {
+      return;
+    }
+    const removedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const changes = vanished.map(
+      (existing) => ({
+        action: "removed",
+        artifactId: existing.id,
+        artifact: toRemovedPublicArtifact(existing, removedAt),
+        reason: "eviction",
+        durableTombstoneRequired: existing.durableTombstoneRequired || existing.retention !== "ephemeral" ? true : void 0,
+        removedClientId: existing.clientId
+      })
+    );
+    const needsDurableTombstone = changes.some(
+      (change) => change.durableTombstoneRequired === true
+    );
+    const before = this.cloneState();
+    for (const artifact of vanished) {
+      this.artifacts.delete(artifact.id);
+    }
+    try {
+      await this.persistChanges(changes, needsDurableTombstone);
+    } catch (error) {
+      writeStderrLine(
+        `[artifacts] session=${this.sessionId} action=vanish_forget_failed artifactIds=${JSON.stringify(
+          vanished.map((artifact) => artifact.id)
+        )} reason=${JSON.stringify(
+          error instanceof Error ? error.message : String(error)
+        )}`
+      );
+      this.restoreState(before);
+    }
+  }
   getRealWorkspaceCwd() {
     if (!this.realWorkspaceCwdPromise) {
       const promise = fs.realpath(this.workspaceCwd).catch((error) => {
@@ -2807,7 +2894,7 @@ var SessionArtifactStore = class {
       (artifact) => !createdInThisBatch.has(artifact.id)
     );
     const now = Date.now();
-    const staleWorkspaceCandidates = candidates.filter((artifact) => artifact.workspacePath).filter((artifact) => shouldRefreshWorkspaceStatus(artifact, now));
+    const staleWorkspaceCandidates = candidates.filter((artifact) => artifact.workspacePath).filter((artifact) => needsWorkspaceStatusRefresh(artifact, now));
     await runInBatches(
       staleWorkspaceCandidates,
       WORKSPACE_STATUS_REFRESH_BATCH_SIZE,
@@ -2824,7 +2911,7 @@ var SessionArtifactStore = class {
       removed.push({
         action: "removed",
         artifactId: artifact.id,
-        artifact: toPublicArtifact(artifact),
+        artifact: toRemovedPublicArtifact(artifact),
         durableTombstoneRequired: artifact.durableTombstoneRequired,
         reason: "eviction"
       });
@@ -2947,7 +3034,10 @@ function mergeArtifact(existing, incoming) {
     trustedPublisher: existing.trustedPublisher || incoming.trustedPublisher,
     clientRetained: existing.clientRetained || incoming.clientRetained,
     lastStatAt: publishedUpdate || existing.storage === "published" ? void 0 : incoming.lastStatAt ?? existing.lastStatAt,
-    updatedAt: existing.updatedAt
+    updatedAt: existing.updatedAt,
+    lastObservedSha256: void 0,
+    lastObservedSizeBytes: void 0,
+    lastObservedMtimeMs: void 0
   };
   if (publishedUpdate) {
     next.title = incoming.title;
@@ -3046,7 +3136,7 @@ function mergeMetadata(existing, incoming) {
   const merged = { ...existing.metadata ?? {} };
   let changed = false;
   for (const [key, value] of Object.entries(incoming.metadata)) {
-    if ((key === WORKSPACE_CONTENT_SHA256_METADATA_KEY || key === WORKSPACE_CONTENT_MTIME_MS_METADATA_KEY) && merged[key] !== value) {
+    if (isAdoptableContentFingerprintKey(key) && merged[key] !== value) {
       merged[key] = value;
       changed = true;
     } else if (!Object.hasOwn(merged, key)) {
@@ -3082,14 +3172,26 @@ function countByRetentionSource(artifacts) {
   return counts;
 }
 __name(countByRetentionSource, "countByRetentionSource");
+function isVanishedAutoRecordedWorkspaceArtifact(artifact) {
+  return artifact.toolName === "write_file" && artifact.workspacePath !== void 0 && artifact.status === "missing" && artifact.missingFromStatError !== true && artifact.hideWorkspacePath !== true;
+}
+__name(isVanishedAutoRecordedWorkspaceArtifact, "isVanishedAutoRecordedWorkspaceArtifact");
 function shouldRefreshWorkspaceStatus(artifact, now) {
   return artifact.lastStatAt === void 0 || now - artifact.lastStatAt >= WORKSPACE_STATUS_REFRESH_TTL_MS;
 }
 __name(shouldRefreshWorkspaceStatus, "shouldRefreshWorkspaceStatus");
+function needsWorkspaceStatusRefresh(artifact, now) {
+  return shouldRefreshWorkspaceStatus(artifact, now) || shouldRecheckWriteFilePresence(artifact);
+}
+__name(needsWorkspaceStatusRefresh, "needsWorkspaceStatusRefresh");
+function shouldRecheckWriteFilePresence(artifact) {
+  return artifact.toolName === "write_file" && (artifact.status === "available" || artifact.status === "missing" && artifact.missingFromStatError !== true && artifact.hideWorkspacePath !== true);
+}
+__name(shouldRecheckWriteFilePresence, "shouldRecheckWriteFilePresence");
 function selectEvictionCandidate(candidates, sourceCounts) {
   return oldest(
     candidates,
-    (artifact) => artifact.status === "missing" && !artifact.clientRetained
+    (artifact) => artifact.status === "missing" && artifact.missingFromStatError !== true && !artifact.clientRetained
   ) ?? oldest(
     candidates,
     (artifact) => !artifact.clientRetained && sourceCounts[artifact.retentionSource] > SOURCE_RESERVATIONS[artifact.retentionSource]
@@ -3176,6 +3278,10 @@ function toPublicArtifact(artifact) {
   };
 }
 __name(toPublicArtifact, "toPublicArtifact");
+function toRemovedPublicArtifact(artifact, removedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  return { ...toPublicArtifact(artifact), updatedAt: removedAt };
+}
+__name(toRemovedPublicArtifact, "toRemovedPublicArtifact");
 function persistedArtifactToInput(artifact) {
   return {
     title: artifact.title,
@@ -3202,7 +3308,7 @@ function workspaceExpectedFromArtifact(artifact) {
     return void 0;
   }
   return {
-    sizeBytes: artifact.sizeBytes,
+    sizeBytes: recordedWorkspaceSizeBytes(artifact),
     mtimeMs: artifact.metadata?.[WORKSPACE_CONTENT_MTIME_MS_METADATA_KEY],
     sha256: artifact.metadata?.[WORKSPACE_CONTENT_SHA256_METADATA_KEY]
   };
@@ -3649,8 +3755,13 @@ function normalizeMetadata(metadata, options = {}) {
     if (isPrototypeMetadataKey(key)) {
       continue;
     }
-    if (options.budget !== "persisted" && isReservedWorkspaceMetadataKey(key)) {
-      continue;
+    if (options.budget !== "persisted") {
+      if (isReservedWorkspaceMetadataKey(key)) {
+        continue;
+      }
+      if (key === PUBLISHED_CONTENT_SHA256_METADATA_KEY && options.trustedPublisher !== true) {
+        continue;
+      }
     }
     if (!key) {
       throw new SessionArtifactValidationError(
@@ -3768,16 +3879,16 @@ async function getWorkspaceStatus(workspacePath, realWorkspaceCwd, expected, opt
     if (!relative || isOutsidePath(relative)) {
       return { status: "missing", escaped: true };
     }
-    const preOpenStat = await fs.lstat(realPath);
+    const preOpenStat = await fs.lstat(realPath, { bigint: true });
     const handle = await fs.open(
       realPath,
       fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW
     );
     try {
-      const stat = await handle.stat();
-      if (!isSameFile(preOpenStat, stat)) {
+      if (!isSameFile(preOpenStat, await handle.stat({ bigint: true }))) {
         return { status: "missing", escaped: true };
       }
+      const stat = await handle.stat();
       if (!stat.isFile()) {
         throw new Error("path is not a regular file");
       }
@@ -3818,7 +3929,8 @@ async function getWorkspaceStatus(workspacePath, realWorkspaceCwd, expected, opt
         return {
           status: "changed",
           sizeBytes: stat.size,
-          mtimeMs: stat.mtimeMs
+          mtimeMs: stat.mtimeMs,
+          sha256
         };
       }
       return {
@@ -3857,23 +3969,51 @@ async function hashFile(handle) {
 }
 __name(hashFile, "hashFile");
 function withWorkspaceContentHashMetadata(metadata, workspaceStatus) {
-  if (workspaceStatus?.status !== "available" || !workspaceStatus.sha256) {
+  if (workspaceStatus?.status !== "available" || workspaceStatus.sha256 === void 0 && workspaceStatus.sizeBytes === void 0) {
     return metadata;
   }
   const next = {
     ...metadata ?? {},
-    [WORKSPACE_CONTENT_SHA256_METADATA_KEY]: workspaceStatus.sha256,
-    ...workspaceStatus.mtimeMs !== void 0 ? { [WORKSPACE_CONTENT_MTIME_MS_METADATA_KEY]: workspaceStatus.mtimeMs } : {}
+    ...workspaceStatus.sha256 ? { [WORKSPACE_CONTENT_SHA256_METADATA_KEY]: workspaceStatus.sha256 } : {},
+    ...workspaceStatus.mtimeMs !== void 0 ? { [WORKSPACE_CONTENT_MTIME_MS_METADATA_KEY]: workspaceStatus.mtimeMs } : {},
+    ...workspaceStatus.sizeBytes !== void 0 ? {
+      [WORKSPACE_CONTENT_SIZE_BYTES_METADATA_KEY]: workspaceStatus.sizeBytes
+    } : {}
   };
   return next;
 }
 __name(withWorkspaceContentHashMetadata, "withWorkspaceContentHashMetadata");
+function recordedWorkspaceSizeBytes(artifact) {
+  const recorded = artifact.metadata?.[WORKSPACE_CONTENT_SIZE_BYTES_METADATA_KEY];
+  if (typeof recorded === "number" && Number.isFinite(recorded)) {
+    return recorded;
+  }
+  return artifact.sizeBytes;
+}
+__name(recordedWorkspaceSizeBytes, "recordedWorkspaceSizeBytes");
+function recordWorkspaceObservation(artifact, status) {
+  const hadObservation = artifact.lastObservedSha256 !== void 0 || artifact.lastObservedSizeBytes !== void 0 || artifact.lastObservedMtimeMs !== void 0;
+  let changed = false;
+  if (hadObservation) {
+    if (status.sha256 !== void 0 && artifact.lastObservedSha256 !== void 0) {
+      changed = status.sha256 !== artifact.lastObservedSha256;
+    } else {
+      changed = status.sizeBytes !== artifact.lastObservedSizeBytes || status.mtimeMs !== artifact.lastObservedMtimeMs;
+    }
+  }
+  artifact.lastObservedSha256 = status.sha256;
+  artifact.lastObservedSizeBytes = status.sizeBytes;
+  artifact.lastObservedMtimeMs = status.mtimeMs;
+  return changed;
+}
+__name(recordWorkspaceObservation, "recordWorkspaceObservation");
 function isWorkspaceContentChanged(artifact, status) {
   if (status.status !== "available") {
     return false;
   }
   const expectedSha256 = artifact.metadata?.[WORKSPACE_CONTENT_SHA256_METADATA_KEY];
-  if (artifact.sizeBytes !== void 0 && status.sizeBytes !== void 0 && status.sizeBytes !== artifact.sizeBytes) {
+  const expectedSize = recordedWorkspaceSizeBytes(artifact);
+  if (expectedSize !== void 0 && status.sizeBytes !== void 0 && status.sizeBytes !== expectedSize) {
     return true;
   }
   return typeof expectedSha256 === "string" && status.sha256 !== void 0 && status.sha256 !== expectedSha256;
@@ -10065,10 +10205,10 @@ function createAcpSessionBridge(opts) {
         if (pr === null || typeof pr !== "object" || typeof pr.number !== "number" || !Number.isInteger(pr.number) || pr.number <= 0 || typeof pr.url !== "string" || pr.url.length > SESSION_PR_URL_MAX_LENGTH || !/^https?:\/\//i.test(pr.url) || // The url is interpolated into the stderr audit line — control
         // characters would let a client forge log lines (the displayName
         // branch rejects them for the same reason).
-        hasControlCharacter2(pr.url)) {
+        hasControlCharacter2(pr.url) || pr.state !== void 0 && pr.state !== "open" && pr.state !== "merged" && pr.state !== "closed") {
           throw new InvalidSessionMetadataError(
             "pr",
-            `must be an object with a positive integer \`number\` and an http(s) \`url\` of at most ${SESSION_PR_URL_MAX_LENGTH} characters, without control characters`
+            `must be an object with a positive integer \`number\` and an http(s) \`url\` of at most ${SESSION_PR_URL_MAX_LENGTH} characters, without control characters, and an optional \`state\` of \`open\`, \`merged\`, or \`closed\``
           );
         }
       }
@@ -10124,11 +10264,22 @@ function createAcpSessionBridge(opts) {
         const bound = metadata.pr;
         const existing = entry.prs ?? [];
         const latest = existing[existing.length - 1];
-        if (latest?.number === bound.number && latest.url === bound.url) {
+        if (latest?.number === bound.number && latest.url === bound.url && // A re-bind carrying a new state is a change: the live entry,
+        // the metadata event, and the catalog revision must all see it.
+        (bound.state === void 0 || bound.state === latest.state)) {
         } else {
+          const known = existing.find(
+            (p) => p.number === bound.number && canonicalSessionPrUrl(p.url) === canonicalSessionPrUrl(bound.url)
+          );
           entry.prs = [
             ...existing.filter((p) => p.number !== bound.number),
-            { number: bound.number, url: bound.url }
+            {
+              number: bound.number,
+              url: bound.url,
+              ...bound.state ?? known?.state ? {
+                state: bound.state ?? known?.state
+              } : {}
+            }
           ].slice(-SESSION_PR_LIST_LIMIT);
           markSessionCatalogChanged();
           writeStderrLine(
@@ -10158,7 +10309,20 @@ function createAcpSessionBridge(opts) {
     seedSessionPrs(sessionId, prs) {
       const entry = byId.get(sessionId);
       if (!entry || entry.prs && entry.prs.length > 0) return;
-      entry.prs = prs.map(({ number, url }) => ({ number, url })).slice(-SESSION_PR_LIST_LIMIT);
+      entry.prs = prs.map(({ number, url, state }) => ({
+        number,
+        url,
+        ...state ? { state } : {}
+      })).slice(-SESSION_PR_LIST_LIMIT);
+    },
+    setSessionPrs(sessionId, prs) {
+      const entry = byId.get(sessionId);
+      if (!entry) return;
+      entry.prs = prs.map(({ number, url, state }) => ({
+        number,
+        url,
+        ...state ? { state } : {}
+      })).slice(-SESSION_PR_LIST_LIMIT);
     },
     async getSessionArtifacts(sessionId, context) {
       const entry = byId.get(sessionId);

package/chunks/{chunk-FBSSIAAQ.js → chunk-73RM4POK.js}

@@ -2,30 +2,30 @@
 "use strict";
 import {
   getExtensionManager
-} from "./chunk-PFCQ62V4.js";
+} from "./chunk-6ZPDLGHN.js";
 import {
   parseChannelConfig
-} from "./chunk-HVQ3B7FF.js";
+} from "./chunk-Y5S7LBOZ.js";
 import {
   getPlugin,
   registerPlugin
-} from "./chunk-5XBFCMWD.js";
+} from "./chunk-3XKLXHGK.js";
 import {
   sanitizeLogText
-} from "./chunk-E55H6BZ7.js";
+} from "./chunk-ICURCKIU.js";
 import {
   loadSettings
-} from "./chunk-F7TNAPZ4.js";
+} from "./chunk-AIAOIFY4.js";
 import {
   hashDaemonWorkspace
-} from "./chunk-HVEYF6VT.js";
+} from "./chunk-3WK3QDNV.js";
 import {
   Storage
 } from "./chunk-UHQFIS7N.js";
 import {
   writeStderrLine,
   writeStdoutLine
-} from "./chunk-KGJGEEVR.js";
+} from "./chunk-7FA2II6K.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-KGJGEEVR.js → chunk-7FA2II6K.js}

@@ -32,13 +32,22 @@ var writeStderrLineSafe = /* @__PURE__ */ __name((message) => {
 var clearScreen = /* @__PURE__ */ __name(() => {
   console.clear();
 }, "clearScreen");
+var ignoreBrokenPipe = /* @__PURE__ */ __name(() => {
+  process.stdout.on("error", (err) => {
+    if (err.code === "EPIPE") process.stdout.destroy();
+  });
+  process.stderr.on("error", (err) => {
+    if (err.code === "EPIPE") process.stderr.destroy();
+  });
+}, "ignoreBrokenPipe");
 
 export {
   writeStdoutLine,
   writeStderrLine,
   writeStdoutLineSafe,
   writeStderrLineSafe,
-  clearScreen
+  clearScreen,
+  ignoreBrokenPipe
 };
 /**
  * @license