@codexhost/cli-darwin-arm64 0.18.0-beta.3 → 0.18.0-beta.4

package/app/web-modules/server.mjs

@@ -66895,7 +66895,7 @@ function hasOnlyKeys(value, required2, optional2) {
 }
 
 // apps/web-ui/packages/api/gateway/src/stream-server.ts
-var MAX_MISSED_HEARTBEATS = 2, RemoteStreamMuxServer = class {
+var HEARTBEAT_TIMEOUT_MS = 10 * 6e4, RemoteStreamMuxServer = class {
   /**
    * @param open - Gateway stream dispatcher.
    * @param failure - Gateway error-to-wire mapper.
@@ -66914,7 +66914,7 @@ var MAX_MISSED_HEARTBEATS = 2, RemoteStreamMuxServer = class {
   streamInboxBytes;
   server = new import_websocket_server2.default({ noServer: !0 });
   connections = /* @__PURE__ */ new Set();
-  missedHeartbeats = /* @__PURE__ */ new WeakMap();
+  lastPongAt = /* @__PURE__ */ new WeakMap();
   heartbeatTimer;
   /**
    * Upgrade one admitted request and begin serving its logical streams. Every
@@ -66929,8 +66929,8 @@ var MAX_MISSED_HEARTBEATS = 2, RemoteStreamMuxServer = class {
     this.server.handleUpgrade(req, socket, head, (websocket) => {
       let release = bindPeer(websocket, peer);
       if (release === void 0) return;
-      this.missedHeartbeats.set(websocket, 0), websocket.on("pong", () => {
-        this.missedHeartbeats.set(websocket, 0);
+      this.lastPongAt.set(websocket, performance.now()), websocket.on("pong", () => {
+        this.lastPongAt.set(websocket, performance.now());
       }), this.startHeartbeat();
       let bound = (endpoint, payload, uplink, control, window2) => this.open(endpoint, payload, uplink, peer, control, window2), done = new RemoteStreamMuxConnection(
         websocket,
@@ -66955,17 +66955,16 @@ var MAX_MISSED_HEARTBEATS = 2, RemoteStreamMuxServer = class {
   /** Start one `unref()` timer after the first upgrade; it spans empty-client periods until close(). */
   startHeartbeat() {
     this.heartbeatTimer === void 0 && (this.heartbeatTimer = setInterval(() => {
-      for (let socket of this.server.clients) {
-        if (socket.readyState !== wrapper_default.OPEN) continue;
-        let missed = this.missedHeartbeats.get(socket);
-        if (missed >= MAX_MISSED_HEARTBEATS) {
-          setImmediate(() => {
-            this.missedHeartbeats.get(socket) >= MAX_MISSED_HEARTBEATS && socket.terminate();
-          });
-          continue;
+      for (let socket of this.server.clients)
+        if (socket.readyState === wrapper_default.OPEN) {
+          if (performance.now() - this.lastPongAt.get(socket) >= HEARTBEAT_TIMEOUT_MS) {
+            setImmediate(() => {
+              socket.readyState === wrapper_default.OPEN && performance.now() - this.lastPongAt.get(socket) >= HEARTBEAT_TIMEOUT_MS && socket.terminate();
+            });
+            continue;
+          }
+          socket.ping();
         }
-        this.missedHeartbeats.set(socket, missed + 1), socket.ping();
-      }
     }, this.heartbeatIntervalMs), this.heartbeatTimer.unref());
   }
 }, RemoteStreamMuxConnection = class {
@@ -68385,12 +68384,17 @@ var clientThreadPinsSchema = external_exports.object({ threadIds: external_expor
 });
 
 // packages/shared-contracts/dist/thread-catalog.js
-var THREAD_CATALOG_READ_METHOD = "codexhost/thread/catalog/read", threadCatalogReadParamsSchema = external_exports.object({ includeArchived: external_exports.boolean().optional() }).strict(), threadCatalogReadResultSchema = external_exports.object({
+var THREAD_CATALOG_READ_METHOD = "codexhost/thread/catalog/read", threadCatalogReadParamsSchema = external_exports.object({
+  includeArchived: external_exports.boolean().optional(),
+  /** Absent means first page; null means this branch is exhausted. Native cursors only. */
+  officialCursor: external_exports.object({ live: external_exports.string().nullable(), archived: external_exports.string().nullable().optional() }).strict().optional()
+}).strict(), threadCatalogReadResultSchema = external_exports.object({
   threads: external_exports.array(jsonObjectSchema),
   ownership: external_exports.array(threadOwnershipSchema),
   /** Known archived IDs, including visible local external records even when their rows are
-   * excluded. Native archived IDs are complete only when includeArchived is true. */
-  archivedThreadIds: external_exports.array(hostThreadIdSchema)
+   * excluded. Native archived IDs describe only the returned page, never a complete set. */
+  archivedThreadIds: external_exports.array(hostThreadIdSchema),
+  officialCursor: external_exports.object({ live: external_exports.string().nullable(), archived: external_exports.string().nullable().optional() }).strict().optional()
 }).strict();
 
 // packages/shared-contracts/dist/voice.js
@@ -68611,7 +68615,7 @@ var IDLE_RELEASE_TIMEOUT_MINUTES_MIN = 5, IDLE_RELEASE_TIMEOUT_MINUTES_MAX = 144
   timeoutMinutes: external_exports.number().int().min(IDLE_RELEASE_TIMEOUT_MINUTES_MIN).max(IDLE_RELEASE_TIMEOUT_MINUTES_MAX)
 }), DEFAULT_IDLE_RELEASE_SETTINGS = Object.freeze({
   enabled: !1,
-  timeoutMinutes: 30
+  timeoutMinutes: 10
 });
 
 // packages/shared-contracts/dist/harness-preferences.js
@@ -74354,6 +74358,111 @@ var KEYS_FILE = "push-keys.json", SUBSCRIPTIONS_FILE = "push-subscriptions.json"
   }
 };
 
+// packages/web-server/src/ch-thread-title.ts
+import { basename as basename2, win32 as win322 } from "node:path";
+function threadListTitle(row) {
+  let name2 = row.name?.trim();
+  if (name2) return name2;
+  let preview = row.preview?.replace(/\s+/gu, " ").trim();
+  if (preview) {
+    let characters = Array.from(preview);
+    return characters.length > 80 ? `${characters.slice(0, 80).join("")}\u2026` : preview;
+  }
+  let cwd = row.cwd ?? "", project2 = /^[a-z]:[\\/]|^\\\\/iu.test(cwd) ? win322.basename(cwd) : basename2(cwd);
+  return project2.trim() ? project2 : row.id;
+}
+
+// packages/web-server/src/ch-push-notifications.ts
+var INTERACTION_METHODS = /* @__PURE__ */ new Set([
+  "item/commandExecution/requestApproval",
+  "item/fileChange/requestApproval",
+  "item/tool/requestUserInput",
+  "mcpServer/elicitation/request",
+  "codexhost/thread/questions/updated"
+]), ChPushNotifications = class {
+  constructor(host, push2) {
+    this.host = host;
+    this.push = push2;
+    this.unsubscribe = host.subscribe((event) => this.receive(event));
+  }
+  host;
+  push;
+  unsubscribe;
+  reads = /* @__PURE__ */ new Map();
+  delivered = /* @__PURE__ */ new Set();
+  epoch;
+  sequence = 0;
+  generation = 0;
+  online = !1;
+  closed = !1;
+  receive(event) {
+    if (this.closed) return;
+    if (event.type === "connection") {
+      this.online = event.online, event.online || this.generation++;
+      return;
+    }
+    if (event.type === "hello") {
+      this.epoch !== event.cursor.epoch && (this.epoch = event.cursor.epoch, this.delivered.clear(), this.sequence = 0, this.generation++), event.reset && (this.sequence = event.cursor.sequence);
+      return;
+    }
+    if (event.type !== "changed" || event.cursor.epoch !== this.epoch || event.cursor.sequence <= this.sequence || (this.sequence = event.cursor.sequence, this.push.subscriptionCount === 0 || event.method !== "turn/completed" && !INTERACTION_METHODS.has(event.method)))
+      return;
+    let generation = this.generation, reading = (this.reads.get(event.threadId) ?? Promise.resolve()).then(() => this.reconcile(event, generation)).catch((error51) => {
+      console.error("[push] Host notification failed", event.threadId, error51);
+    }).finally(() => {
+      this.reads.get(event.threadId) === reading && this.reads.delete(event.threadId);
+    });
+    this.reads.set(event.threadId, reading);
+  }
+  current(generation) {
+    return !this.closed && this.online && this.generation === generation;
+  }
+  async reconcile(event, generation) {
+    if (!this.current(generation) || this.push.subscriptionCount === 0) return;
+    let snapshot = await this.host.snapshot(event.threadId, { truncateToolOutput: !0 });
+    if (!this.current(generation) || snapshot.cursor.epoch !== event.cursor.epoch) return;
+    let title = threadListTitle({ ...snapshot.thread, id: event.threadId }), messages2 = [];
+    if (event.method === "turn/completed") {
+      let turn = snapshot.turnsPage.data.find((value) => value.status !== "inProgress");
+      turn && (turn.status === "completed" || turn.status === "failed") && messages2.push({
+        key: JSON.stringify([event.cursor.epoch, event.threadId, "turn", turn.id]),
+        message: {
+          kind: turn.status === "failed" ? "error" : "turn",
+          title,
+          body: turn.status === "failed" ? "\u8FD0\u884C\u5931\u8D25" : "\u5DF2\u56DE\u590D"
+        }
+      });
+    }
+    for (let pending of snapshot.interactions)
+      messages2.push({
+        key: JSON.stringify([event.cursor.epoch, event.threadId, "interaction", pending.requestId]),
+        message: {
+          kind: pending.kind,
+          title,
+          body: pending.kind === "approval" ? "\u5F85\u6388\u6743" : "\u5F85\u56DE\u7B54"
+        }
+      });
+    for (let { key, message: message2 } of messages2) {
+      if (!this.current(generation)) return;
+      if (!this.delivered.has(key)) {
+        if (this.delivered.add(key), this.delivered.size > 512) {
+          let oldest = this.delivered.values().next().value;
+          oldest !== void 0 && this.delivered.delete(oldest);
+        }
+        await this.push.notify({
+          ...message2,
+          tag: event.threadId,
+          sessionId: event.threadId,
+          url: `./?session=${encodeURIComponent(event.threadId)}`
+        });
+      }
+    }
+  }
+  close() {
+    this.closed = !0, this.unsubscribe(), this.reads.clear(), this.delivered.clear();
+  }
+};
+
 // packages/web-server/src/plugins.ts
 var CLIENT_PLUGINS = [
   "@deepseek-ai/dsh-api-gateway",
@@ -74589,20 +74698,6 @@ function projectGroupRoot(snapshot, threadId, cwd) {
   return matches2.length ? matches2.sort((a, b) => b.length - a.length)[0] : project2?.rootPaths[0];
 }
 
-// packages/web-server/src/ch-thread-title.ts
-import { basename as basename2, win32 as win322 } from "node:path";
-function threadListTitle(row) {
-  let name2 = row.name?.trim();
-  if (name2) return name2;
-  let preview = row.preview?.replace(/\s+/gu, " ").trim();
-  if (preview) {
-    let characters = Array.from(preview);
-    return characters.length > 80 ? `${characters.slice(0, 80).join("")}\u2026` : preview;
-  }
-  let cwd = row.cwd ?? "", project2 = /^[a-z]:[\\/]|^\\\\/iu.test(cwd) ? win322.basename(cwd) : basename2(cwd);
-  return project2.trim() ? project2 : row.id;
-}
-
 // packages/web-server/src/ch-file-operations.ts
 function conversationItems(turn) {
   if (turn.codexhostFileOperations === void 0) return turn.items;
@@ -75390,7 +75485,7 @@ var TurnProjector = class {
     this.step += 1, this.stepOpen = !0, this.stepHasTools = !1, this.messageCommitted = !1, this.blocks = [], this.blockByItem.clear(), this.log.append("step/start", { turn: this.turn, step: this.step });
   }
   closeStep() {
-    this.stepOpen && (!this.messageCommitted && this.blocks.some((block) => block.text !== "") ? this.commitMessage([]) : this.log.endAttempt(void 0), this.log.append("step/end", { turn: this.turn, step: this.step }), this.stepOpen = !1);
+    this.stepOpen && (!this.messageCommitted && this.blocks.some((block) => block.text !== "") ? this.commitMessage([]) : this.log.endAttempt(void 0), [...this.tools.values()].some((tool) => tool.step === this.step) || this.log.append("step/end", { turn: this.turn, step: this.step }), this.stepOpen = !1);
   }
   ensureAttempt() {
     this.options.live && this.log.activeAttempt === void 0 && this.log.startAttempt(this.turn, this.step);
@@ -75482,6 +75577,7 @@ var TurnProjector = class {
       arguments: argumentsJson
     }), early = this.earlyOutput.get(item.itemId) ?? "";
     this.earlyOutput.delete(item.itemId), this.tools.set(item.itemId, {
+      step: this.step,
       callId,
       name: call.name,
       args: call.args,
@@ -75519,7 +75615,7 @@ var TurnProjector = class {
       let call = toolCallOf(tool.item, this.options.cwd);
       tool.name = call.name, tool.args = call.args, this.log.append("tool/call", {
         turn: this.turn,
-        step: this.step,
+        step: tool.step,
         callId: tool.callId,
         name: call.name,
         arguments: JSON.stringify(call.args)
@@ -75553,7 +75649,7 @@ var TurnProjector = class {
     let meta3 = item.type === "fileChange" ? { diffs: item.changes.map(diffTexts) } : isError ? void 0 : editMeta(tool.name, tool.args);
     this.log.append("tool/result", {
       turn: this.turn,
-      step: this.step,
+      step: tool.step,
       message: {
         role: "tool",
         source: { kind: "tool", callId: tool.callId },
@@ -75570,7 +75666,7 @@ var TurnProjector = class {
         }
       } : {},
       ...meta3 === void 0 ? {} : { meta: meta3 }
-    }, { surfaceOp: "append", sourceEventSeqs: [tool.callSeq] });
+    }, { surfaceOp: "append", sourceEventSeqs: [tool.callSeq] }), (tool.step !== this.step || !this.stepOpen) && ![...this.tools.values()].some((pending) => pending.step === tool.step) && this.log.append("step/end", { turn: this.turn, step: tool.step });
   }
   /** Close the Turn, optionally carrying the source's final reply identity. */
   finish(outcome2, finalAnswerItemId) {
@@ -75676,6 +75772,9 @@ function itemOf(item, reasoningPreviewIds) {
       return;
   }
 }
+function userMessageIdentity(item) {
+  return JSON.stringify([item.content, item.clientId ?? null]);
+}
 function nativeTime(seconds) {
   return typeof seconds == "number" && Number.isFinite(seconds) && seconds >= 0 ? seconds * 1e3 : void 0;
 }
@@ -75786,8 +75885,23 @@ var ChThreadView = class _ChThreadView {
     for (let turn of thread.turns) {
       let view = this.turns.get(turn.id);
       if (!view) continue;
-      let previous = this.thread.turns.find((item) => item.id === turn.id), ids = new Set(conversationItems(turn).map((item) => item.id));
-      if (!view.done && [...view.items.keys()].some((id) => !ids.has(id)) || JSON.stringify(previous?.items.filter((item) => item.type === "userMessage")) !== JSON.stringify(turn.items.filter((item) => item.type === "userMessage")))
+      let items = conversationItems(turn), ids = new Set(items.map((item) => item.id)), users = items.filter((item) => item.type === "userMessage"), published = [...view.started], lastUser = published.findLastIndex((id) => view.userMessages.has(id)), reasoningPreviewIds = new Set(
+        items.filter((item) => item.type === "reasoning").map((item) => item.id)
+      ), projections = new Map(
+        items.map((item) => [item.id, itemOf(item, reasoningPreviewIds)])
+      ), retained = items.filter((item) => {
+        let projected = projections.get(item.id);
+        return view.started.has(item.id) || projected && (projected.type !== "fileChange" || hasFileChangePath(projected));
+      }), firstNewUser = items.findIndex(
+        (item) => item.type === "userMessage" && !view.userMessages.has(item.id)
+      );
+      if (!view.done && [...view.items.keys()].some((id) => !ids.has(id)) || published.slice(0, lastUser + 1).some((id, index) => retained[index]?.id !== id) || [...view.userMessages].some(([id, identity], index) => {
+        let user = users[index];
+        return !user || user.id !== id || userMessageIdentity(user) !== identity;
+      }) || view.done && (users.length !== view.userMessages.size || items.some((item) => {
+        let projected = projections.get(item.id);
+        return projected && (JSON.stringify(projected) !== JSON.stringify(view.items.get(item.id)) || typeof item.status == "string" && ["completed", "failed", "declined", "interrupted"].includes(item.status) && !view.completed.has(item.id));
+      })) || firstNewUser !== -1 && items.slice(firstNewUser + 1).some((item) => view.started.has(item.id)))
         throw new SessionRuntimeError("host/items-replaced", "CH replaced already projected Items.");
     }
     Object.assign(this.thread, thread), this.log.setProjection("title", threadListTitle(thread)), this.log.setProjection("codexhostImportSource", thread.codexhostImportSource ?? null), this.log.setProjection("sessionListMetadata", {
@@ -75857,7 +75971,7 @@ var ChThreadView = class _ChThreadView {
   projectTurns(thread) {
     let previousEnd = thread.createdAt * 1e3;
     for (let turn of thread.turns) {
-      let view = this.turns.get(turn.id), complete = finished(turn.status), start = nativeTime(turn.startedAt) ?? (complete ? previousEnd : Date.now()), end = Math.max(
+      let items = conversationItems(turn), view = this.turns.get(turn.id), complete = finished(turn.status), start = nativeTime(turn.startedAt) ?? (complete ? previousEnd : Date.now()), end = Math.max(
         start,
         nativeTime(turn.completedAt) ?? (view && !view.done ? Date.now() : start)
       );
@@ -75870,25 +75984,31 @@ var ChThreadView = class _ChThreadView {
           onToolOutput: (id, output) => {
             output === void 0 ? this.liveOutput.delete(id) : this.liveOutput.set(id, output.slice(-8e3));
           }
-        }), input = turn.items.filter((item) => item.type === "userMessage").flatMap((item) => Array.isArray(item.content) ? item.content : []), clientId = turn.items.find(
-          (item) => item.type === "userMessage" && typeof item.clientId == "string"
-        )?.clientId;
-        projector.begin(
-          this.projectInput(input),
-          typeof clientId == "string" ? clientId : void 0
-        ), view = {
+        }), opening = items[0]?.type === "userMessage" ? items[0] : void 0;
+        opening ? projector.begin(
+          this.projectInput(Array.isArray(opening.content) ? opening.content : []),
+          typeof opening.clientId == "string" ? opening.clientId : void 0
+        ) : projector.beginAutonomous([]), view = {
           projector,
           items: /* @__PURE__ */ new Map(),
-          started: /* @__PURE__ */ new Set(),
+          userMessages: new Map(opening ? [[opening.id, userMessageIdentity(opening)]] : []),
+          started: new Set(opening ? [opening.id] : []),
           completed: /* @__PURE__ */ new Set(),
           done: !1
         }, this.turns.set(turn.id, view);
       }
       if (complete || (this.log.clock = void 0), view.done) continue;
-      let items = conversationItems(turn), reasoningPreviewIds = new Set(
+      let reasoningPreviewIds = new Set(
         items.filter((item) => item.type === "reasoning").map((item) => item.id)
       );
       for (let item of items) {
+        if (item.type === "userMessage") {
+          view.userMessages.has(item.id) || (view.projector.steer(
+            this.projectInput(Array.isArray(item.content) ? item.content : []),
+            typeof item.clientId == "string" ? item.clientId : void 0
+          ), view.userMessages.set(item.id, userMessageIdentity(item)), view.started.add(item.id));
+          continue;
+        }
         let projected = itemOf(item, reasoningPreviewIds);
         if (!projected || view.completed.has(item.id)) continue;
         let old = view.items.get(item.id);
@@ -76421,35 +76541,49 @@ async function forkChThread(host, view, atSeq) {
   let threadId = view.thread.id, owner = threadInspectionSchema.parse(
     await host.request("codexhost/thread/inspect", { threadId })
   );
-  if (owner.owner !== "external" || !owner.history.fork)
+  if (owner.history?.fork === !1)
     return forkUnavailable(threadId, "This Thread does not support native forking.");
   let lastTurnId = view.forkTurnId(atSeq);
-  return lastTurnId ? { sessionId: externalThreadForkResultSchema.parse(
+  if (!lastTurnId)
+    return forkUnavailable(
+      threadId,
+      "No completed Turn exists at this fork point. Reopen the conversation."
+    );
+  if (owner.owner === "codex") {
+    let id = (await host.request("thread/fork", {
+      threadId,
+      lastTurnId,
+      excludeTurns: !0
+    }))?.thread?.id;
+    if (typeof id != "string" || !id.trim() || id === threadId)
+      throw new SessionRuntimeError(
+        "session/fork-unconfirmed",
+        "Codex did not confirm a distinct forked Thread. Do not retry automatically.",
+        { sessionId: threadId }
+      );
+    return { sessionId: id };
+  }
+  return { sessionId: externalThreadForkResultSchema.parse(
     await host.request("codexhost/thread/fork", { threadId, lastTurnId })
-  ).threadId } : forkUnavailable(
-    threadId,
-    "No completed Turn exists at this fork point. Reopen the conversation."
-  );
+  ).threadId };
 }
 
 // packages/web-server/src/ch-pinned-threads.ts
 var ChPinnedThreads = class {
-  constructor(host, workspaces2, visible) {
+  constructor(host, workspaces2) {
     this.host = host;
     this.workspaces = workspaces2;
-    this.visible = visible;
     workspaces2.setReferencePins([]);
   }
   host;
   workspaces;
-  visible;
   pending = Promise.resolve();
   refreshing;
   closed = !1;
   sync(change) {
     let next = this.pending.then(async () => {
       if (this.closed) return [];
-      let ids = (await this.host.pins(change)).filter(this.visible);
+      let ids = await this.host.pins(change);
       return this.closed || this.workspaces.setReferencePins(ids), ids;
     });
     return this.pending = next.catch(() => {
@@ -77159,28 +77293,22 @@ function record3(value) {
 function presentation(pending) {
   let interaction = pending.interaction;
   if (interaction.type === "approval") {
-    let labels = interaction.actions.map(
+    let nativeApproval = pending.request.method === "item/commandExecution/requestApproval" || pending.request.method === "item/fileChange/requestApproval", labels = interaction.actions.map(
       (action, index) => interaction.actions.filter((other) => other.label === action.label).length > 1 ? `${action.label} (${index + 1})` : action.label
     );
     return {
       questions: [
         {
           id: "approval",
-          header: interaction.title,
-          question: [
-            interaction.title,
-            interaction.description,
-            interaction.subject ? JSON.stringify(interaction.subject, null, 2) : void 0
-          ].filter(Boolean).join(`
-
-`),
+          question: interaction.title,
+          ...!nativeApproval && interaction.description ? { detail: interaction.description } : {},
           options: labels.map((label) => ({ label })),
           multiSelect: !1,
           allowOther: !1
         }
       ],
       result(value) {
-        let nativeApproval = pending.request.method === "item/commandExecution/requestApproval" || pending.request.method === "item/fileChange/requestApproval", answer = value?.answers?.find(
+        let answer = value?.answers?.find(
           (entry) => entry.id === "approval"
         );
         if (value == null || answer?.selected?.length === 0 && !answer.custom) {
@@ -77395,6 +77523,49 @@ function readToolOutput(log, ref) {
   return { text: text2 };
 }
 
+// packages/web-server/src/ch-session-page.ts
+function decodeCatalogCursor(cursor, includeArchived) {
+  try {
+    let value = threadCatalogReadParamsSchema.parse(JSON.parse(cursor));
+    if (value.includeArchived !== includeArchived || !value.officialCursor)
+      throw new Error("scope mismatch");
+    return value.officialCursor;
+  } catch {
+    throw new SessionRuntimeError("session/list-invalid", "Invalid session list cursor or archive scope.");
+  }
+}
+function nextCatalogCursor(page, includeArchived) {
+  let cursor = page.officialCursor;
+  return cursor && (cursor.live !== null || includeArchived && cursor.archived != null) ? JSON.stringify({ includeArchived, officialCursor: cursor }) : null;
+}
+async function readSessionPage(host, timing, includeArchived, cursor, readPins = () => host.pins()) {
+  let officialCursor = cursor === void 0 ? void 0 : decodeCatalogCursor(cursor, includeArchived), [page, pinned] = await Promise.all([
+    timing.measure(
+      "host_catalog",
+      () => host.request(THREAD_CATALOG_READ_METHOD, {
+        includeArchived,
+        ...officialCursor ? { officialCursor } : {}
+      })
+    ),
+    timing.measure("pins", readPins)
+  ]), present = new Set(page.threads.map((row) => row.id)), missing = [...new Set(pinned)].filter((id) => !present.has(id)), offset = 0;
+  return await Promise.all(
+    Array.from({ length: Math.min(4, missing.length) }, async () => {
+      for (; offset < missing.length; ) {
+        let id = missing[offset++];
+        if (id === void 0) break;
+        let [result, owner] = await Promise.all([
+          host.request("thread/read", { threadId: id, includeTurns: !1 }),
+          host.request("codexhost/thread/ownership/list", { threadIds: [id] }).then((value) => threadOwnershipSchema.parse(value.threads[0]))
+        ]);
+        if (result.thread.id !== id || owner.threadId !== id)
+          throw new Error("Pinned Thread identity mismatch");
+        page.threads.push(result.thread), page.ownership.push(owner);
+      }
+    })
+  ), { page, pinned };
+}
+
 // packages/web-server/src/ch-sessions.ts
 function globalProjectionValues(values2) {
   return Object.fromEntries(
@@ -77420,11 +77591,13 @@ var ChSessions = class {
           "Subagent file uploads are unavailable."
         );
       return id;
-    }) : void 0, this.pins = new ChPinnedThreads(host, workspaces2, (id) => this.threads.hasHarness(id)), workspaces2.setReferenceArchives([]), this.interactions = host.realtime ? new ChInteractions(host.realtime, events2, (id, message2) => {
+    }) : void 0, this.pins = new ChPinnedThreads(host, workspaces2), workspaces2.setReferenceArchives([]), this.interactions = host.realtime ? new ChInteractions(host.realtime, events2, (id, message2) => {
       this.threads.view(id)?.log.setProjection("nativeInteractionError", message2);
     }) : void 0, this.realtime = host.realtime ? new ChRealtime(host.realtime, {
       thread: (id) => this.view(id),
-      catalog: () => this.refresh(),
+      catalog: async () => {
+        await this.refresh();
+      },
       archived: (id, archived) => this.updateArchive(id, archived),
       connection: (online) => {
         this.hostOnline = online, online || this.interactions?.clear();
@@ -77462,8 +77635,7 @@ var ChSessions = class {
   fileInputs;
   rows = /* @__PURE__ */ new Map();
   publishedCatalog;
-  /** Everything derived per Thread. Rows (replaced as a whole by each catalog read)
-   * and drafts (not yet Host Threads) keep their own lifecycles. */
+  /** Loaded rows accumulate across partial official pages; drafts are not Host Threads. */
   threads = new WebThreadStates();
   drafts = /* @__PURE__ */ new Map();
   controls = /* @__PURE__ */ new Set();
@@ -77479,51 +77651,54 @@ var ChSessions = class {
   interactions;
   hostOnline = !0;
   hostEpoch;
-  notifier;
   id(id) {
     return this.drafts.get(id)?.canonicalId ?? id;
   }
-  async refresh(timing, includeArchived = !1) {
+  async refresh(timing, includeArchived = !1, cursor) {
     if (this.closed) return;
-    if (this.refreshing && (!this.refreshingCatalog || includeArchived && !this.refreshingArchives)) {
+    if (this.refreshing && (cursor !== void 0 || !this.refreshingCatalog || includeArchived !== this.refreshingArchives)) {
       let stage = this.refreshingCatalog ? "catalog_wait" : "workspace_wait", pending2 = this.refreshing.catch(() => {
       });
-      return await (timing ? timing.measure(stage, () => pending2) : pending2), this.refresh(timing, includeArchived);
+      return await (timing ? timing.measure(stage, () => pending2) : pending2), this.refresh(timing, includeArchived, cursor);
     }
     let mode = this.refreshing ? "joined" : "started";
     if (!this.refreshing) {
-      this.refreshingCatalog = !0, this.refreshingArchives = includeArchived, this.refreshingTiming = new SessionListTiming();
+      this.refreshingCatalog = cursor === void 0, this.refreshingArchives = includeArchived, this.refreshingTiming = new SessionListTiming();
       let archiveChanges = /* @__PURE__ */ new Map();
       this.refreshingArchiveChanges = archiveChanges, this.refreshing = this.listAll(
         this.refreshingTiming,
         includeArchived,
-        archiveChanges
+        archiveChanges,
+        cursor
       ).finally(() => {
         this.refreshing = void 0, this.refreshingCatalog = !1, this.refreshingArchives = !1, this.refreshingArchiveChanges = void 0, this.refreshingTiming = void 0;
       });
     }
     let pending = this.refreshing, catalogTiming = this.refreshingTiming;
     try {
-      await (timing ? timing.measure("catalog_wait", () => pending) : pending);
+      return await (timing ? timing.measure("catalog_wait", () => pending) : pending);
     } finally {
       timing && catalogTiming && (timing.catalog = { mode, ...catalogTiming.snapshot() });
     }
   }
-  async listAll(timing, includeArchived, archiveChanges) {
-    let known = new Set(this.rows.keys()), snapshot = await timing.measure(
-      "host_catalog",
-      () => this.host.request(
-        THREAD_CATALOG_READ_METHOD,
-        { includeArchived }
-      )
-    );
+  async listAll(timing, includeArchived, archiveChanges, cursor) {
+    let known = new Set(this.rows.keys()), [{ page: snapshot }, definitions] = await Promise.all([
+      readSessionPage(
+        this.host,
+        timing,
+        includeArchived,
+        cursor,
+        () => this.pins.refresh().catch((error51) => (console.error("[session/list] native pins unavailable", error51), [...this.workspaces.pinnedSessionIds()]))
+      ),
+      timing.measure("project_definitions", () => this.host.projects([]))
+    ]);
     if (this.closed) return;
-    let found = new Map(snapshot.threads.map((row) => [row.id, row])), projects = await timing.measure(
+    let found = new Map(snapshot.threads.map((row) => [row.id, row])), projects = { ...await timing.measure(
       "projects",
       () => this.host.projects([.../* @__PURE__ */ new Set([...found.keys(), ...this.rows.keys()])])
-    );
+    ), projects: definitions.projects };
     if (this.closed) return;
-    let snapshotArchives = new Set(snapshot.archivedThreadIds), archivedIds = new Set(includeArchived ? [] : this.workspaces.archivedSessionIds());
+    let snapshotArchives = new Set(snapshot.archivedThreadIds), archivedIds = new Set(this.workspaces.archivedSessionIds());
     for (let id of snapshotArchives) archivedIds.add(id);
     for (let id of found.keys()) snapshotArchives.has(id) || archivedIds.delete(id);
     for (let [id, archived] of archiveChanges)
@@ -77541,27 +77716,13 @@ var ChSessions = class {
     let rows = new Map([...found].filter(([id]) => ownership.has(id)));
     for (let [id, row] of this.rows) {
       let harnessId = this.threads.harnessId(id);
-      if (!(found.has(id) || !harnessId)) {
-        if (known.has(id) && !archiveChanges.has(id) && (includeArchived || !archivedIds.has(id))) {
-          if (harnessId === "codex")
-            try {
-              let refreshed = await this.host.request("thread/read", {
-                threadId: id,
-                includeTurns: !1
-              });
-              refreshed.thread.id === id && (rows.set(id, refreshed.thread), ownership.set(id, harnessId));
-            } catch {
-            }
-          continue;
-        }
-        rows.set(id, row), ownership.set(id, harnessId);
-      }
+      found.has(id) || !harnessId || harnessId !== "codex" && known.has(id) && !archiveChanges.has(id) && (includeArchived || !archivedIds.has(id)) || (rows.set(id, row), ownership.set(id, harnessId));
     }
-    this.threads.replaceHarnesses(ownership), this.rows = rows, timing.count("visibleRows", rows.size), await this.syncWorkspace(timing, projects), !this.closed && (timing.measureSync(
-      "archive_sync",
-      () => this.workspaces.setReferenceArchives([...archivedIds].sort())
-    ), await timing.measure("catalog_publish", () => this.publishCatalogChanges()), this.pins.refresh().catch(() => {
-    }), this.catalogReadAt = Date.now());
+    if (this.threads.replaceHarnesses(ownership), this.rows = rows, timing.count("visibleRows", rows.size), await this.syncWorkspace(timing, projects), !this.closed)
+      return timing.measureSync(
+        "archive_sync",
+        () => this.workspaces.setReferenceArchives([...archivedIds].sort())
+      ), await timing.measure("catalog_publish", () => this.publishCatalogChanges(cursor !== void 0)), this.catalogReadAt = Date.now(), snapshot;
   }
   async syncWorkspace(timing = new SessionListTiming(), snapshot) {
     let projects = snapshot ?? await timing.measure("projects", () => this.host.projects([...this.rows.keys()]));
@@ -77581,7 +77742,7 @@ var ChSessions = class {
       }
       for (let draft of this.drafts.values())
         draft.canonicalId || (groups.set(draft.id, draft.cwd), draft.cwd || projectless.add(draft.id));
-      timing.count("workspaceReferences", references.length), this.workspaces.syncReferencedSessions(references, groups, projectless);
+      timing.count("workspaceReferences", references.length), this.workspaces.syncReferencedSessions(references, groups, projectless, projects.projects);
     });
   }
   /** Only fields used by the list summary; projections have their own
@@ -77600,9 +77761,11 @@ var ChSessions = class {
       this.threads.harnessId(row.id)
     ]);
   }
-  async publishCatalogChanges() {
+  async publishCatalogChanges(explicitPage = !1) {
     let before = this.publishedCatalog, next = new Map([...this.rows].map(([id, row]) => [id, this.catalogKey(row)])), changed = before === void 0 ? [] : await Promise.all(
-      [...this.rows.values()].filter((row) => before.get(row.id) !== next.get(row.id)).map((row) => this.summary(row))
+      [...this.rows.values()].filter(
+        (row) => before.get(row.id) !== next.get(row.id) && (!explicitPage || before.has(row.id))
+      ).map((row) => this.summary(row))
     );
     this.publishedCatalog = next;
     for (let [id, row] of this.rows) {
@@ -78004,20 +78167,49 @@ var ChSessions = class {
         return { pinnedSessionIds: await this.pins.sync({ threadId: id, pinned }) };
       });
     rpc2.register("session/list", async (args, context) => {
-      let { includeArchived = !1 } = requestOf(args);
+      let {
+        includeArchived = !1,
+        cursor,
+        sessionId
+      } = requestOf(args);
+      if (sessionId !== void 0) {
+        if (typeof sessionId != "string" || !sessionId || cursor !== void 0)
+          throw new SessionRuntimeError("session/list-invalid", "Invalid direct-link identity.");
+        let draft = this.drafts.get(sessionId);
+        if (draft && !draft.canonicalId)
+          return {
+            items: [await this.draftSummary(draft, !1)],
+            archivedSessionIds: this.workspaces.archivedSessionIds()
+          };
+        let id = this.id(sessionId), owner = await this.owner(id), { thread } = await this.host.request("thread/read", {
+          threadId: id,
+          includeTurns: !1
+        });
+        if (thread.id !== id || owner.owner === "external" && thread.modelProvider !== "codexhost")
+          throw new SessionRuntimeError("session/ownership-unconfirmed", "Thread identity was not confirmed.");
+        return this.rows.set(thread.id, thread), this.threads.setHarness(thread.id, owner.harnessId), {
+          items: [await this.summary(thread)],
+          archivedSessionIds: this.workspaces.archivedSessionIds()
+        };
+      }
       if (typeof includeArchived != "boolean")
         throw new SessionRuntimeError("session/list-invalid", "includeArchived must be a boolean.");
       let timing = context.sessionListTiming ?? new SessionListTiming();
-      await this.refresh(timing, includeArchived);
-      let archivedSessionIds = this.workspaces.archivedSessionIds(), archived = new Set(archivedSessionIds), items = await timing.measure("summaries", async () => [
+      if (cursor !== void 0 && typeof cursor != "string")
+        throw new SessionRuntimeError("session/list-invalid", "cursor must be a string.");
+      let page = await this.refresh(timing, includeArchived, cursor), pageIds = new Set(page?.threads.map((row) => row.id)), archivedSessionIds = this.workspaces.archivedSessionIds(), archived = new Set(archivedSessionIds), items = await timing.measure("summaries", async () => [
         ...await Promise.all(
-          [...this.rows.values()].filter((row) => includeArchived || !archived.has(row.id)).map((row) => this.summary(row))
+          [...this.rows.values()].filter((row) => pageIds.has(row.id) && (includeArchived || !archived.has(row.id))).map((row) => this.summary(row))
         ),
         ...await Promise.all(
           [...this.drafts.values()].filter((d) => !d.canonicalId).map((d) => this.draftSummary(d, !1))
         )
       ]);
-      return timing.count("resultRows", items.length), { items, archivedSessionIds };
+      return timing.count("resultRows", items.length), {
+        items,
+        archivedSessionIds,
+        nextCursor: page ? nextCatalogCursor(page, includeArchived) : null
+      };
     }), rpc2.register("session/create", (args) => this.create(args)), rpc2.register("session/fork", async (args) => {
       let request2 = requestOf(args);
       if (typeof request2.sessionId != "string" || !request2.sessionId || request2.atSeq !== void 0 && (!Number.isSafeInteger(request2.atSeq) || request2.atSeq < 0))
@@ -78084,7 +78276,10 @@ var ChSessions = class {
         };
         return state.view?.log.setProjection("modelSelection", { lastUsed: selection, next: selection }), configuration2;
       }, configuration = publish(
-        await this.host.request("codexhost/thread/model/select", {
+        owner.owner === "codex" && owner.effectiveModel?.id === request2.model ? {
+          effectiveModel: owner.effectiveModel,
+          effectiveThinkingOptionId: owner.effectiveThinkingOptionId
+        } : await this.host.request("codexhost/thread/model/select", {
           threadId: id,
           model: { id: request2.model }
         })
@@ -78124,8 +78319,6 @@ var ChSessions = class {
         }) : await this.host.request("turn/start", {
           threadId,
           input,
-          delivery: "queue",
-          presentationInput: presentation2,
           ...request2.requestId ? { clientUserMessageId: request2.requestId } : {}
         });
       } else
@@ -78213,7 +78406,6 @@ var ChSessions = class {
       let view = await this.view(request2.sessionId);
       return { title: request2.title, seq: view.log.lastSeq };
     }), rpc2.register("session/search", async (args) => {
-      await this.refresh();
       let needle = requestOf(args).query.toLowerCase();
       return {
         items: [...this.rows.values()].map((row) => ({ sessionId: row.id, snippet: threadListTitle(row) })).filter((item) => item.snippet.toLowerCase().includes(needle)).slice(0, 20),
@@ -81467,6 +81659,7 @@ var exec3 = promisify5(execFile5), METHODS = /* @__PURE__ */ new Set([
   "thread/revert",
   "thread/start",
   "thread/resume",
+  "thread/fork",
   "thread/name/set",
   "thread/archive",
   "thread/unarchive",
@@ -83858,7 +84051,7 @@ var MAX_TIMER_DELAY_MS = 2147483647;
 
 // apps/web-ui/packages/api/gateway/src/index.ts
 import z3 from "@deepseek-ai/schemastery";
-var NEVER_ABORTED_SIGNAL = new AbortController().signal, DEFAULT_WEBSOCKET_HEARTBEAT_INTERVAL_MS = 2e3, DEFAULT_STREAM_INBOX_BYTES = 262144, EMPTY_ASYNC_ITERABLE = {
+var NEVER_ABORTED_SIGNAL = new AbortController().signal, DEFAULT_WEBSOCKET_HEARTBEAT_INTERVAL_MS = 3e4, DEFAULT_STREAM_INBOX_BYTES = 262144, EMPTY_ASYNC_ITERABLE = {
   [Symbol.asyncIterator]: () => ({ next: () => Promise.resolve({ value: void 0, done: !0 }) })
 }, UPLINK_DONE2 = { value: void 0, done: !0 }, SRC_JSON_CODEC = { mode: "src-json" }, TypertGatewayError = class extends RemoteError {
   /** Canonical `<namespace>/<method>` endpoint. */
@@ -93459,6 +93652,7 @@ import { execFileSync } from "node:child_process";
 
 // apps/web-ui/packages/subprocess/subprocess-local/src/windows-inspector.ts
 import { spawnSync } from "node:child_process";
+import { win32 as win326 } from "node:path";
 var requireKoffi = createLazyRequire("koffi", import.meta.url);
 function windowsProcessTree(entries, rootPid, started) {
   let root = new Map(entries.map((entry) => [entry.pid, entry])).get(rootPid);
@@ -93516,10 +93710,16 @@ function createWindowsProcessInspector(internals = defaultWindowsProcessInternal
   return new WindowsProcessInspector(internals);
 }
 function taskkillTree(pid, force) {
-  pid <= 0 || spawnSync("taskkill", ["/PID", String(pid), "/T", ...force ? ["/F"] : []], {
-    stdio: "ignore",
-    windowsHide: !0
-  });
+  if (pid <= 0) return;
+  let systemRoot = process.env.SystemRoot ?? process.env.windir;
+  if (!systemRoot || !/^[A-Za-z]:[\\/]/u.test(systemRoot))
+    throw new Error("Windows SystemRoot is unavailable or invalid");
+  let result = spawnSync(
+    win326.join(systemRoot, "System32", "taskkill.exe"),
+    ["/PID", String(pid), "/T", ...force ? ["/F"] : []],
+    { stdio: "ignore", windowsHide: !0 }
+  );
+  if (result.error) throw result.error;
 }
 function isInvalidHandle(value) {
   if (value == null) return !0;
@@ -95337,20 +95537,14 @@ var LocalTerminalHandle = class {
     this.shellActivity = shellActivity;
     this.onQuiescence = onQuiescence;
     this.observeShellExit = observeShellExit;
-    this.pid = terminal.pid;
-    try {
-      this.rootIdentity = inspector.snapshot().tree(this.pid).find((member) => member.pid === this.pid);
-    } catch {
-      this.rootIdentity = void 0;
-    }
-    this.done = this.outcome.promise;
+    this.captureProcessIdentity(), this.done = this.outcome.promise;
     let resume = () => {
       this.outputPaused && (this.outputPaused = !1, this.exited || terminal.resume());
     };
     this.output.on("drain", resume), this.output.once("close", () => {
       this.output.off("drain", resume);
     }), this.dataDisposable = terminal.onData((data2) => {
-      !this.output.write(Buffer2.from(data2, "utf8")) && this.cleanup === void 0 && !this.outputPaused && (this.outputPaused = !0, terminal.pause());
+      this.captureProcessIdentity(), !this.output.write(Buffer2.from(data2, "utf8")) && this.cleanup === void 0 && !this.outputPaused && (this.outputPaused = !0, terminal.pause());
     }), this.exitDisposable = terminal.onExit(({ exitCode, signal: exitSignal }) => {
       if (this.exited) return;
       this.exited = !0, this.managedOwner !== void 0 && this.observeShellExit && this.managedOwner.waitForExit().then(() => {
@@ -95377,7 +95571,10 @@ var LocalTerminalHandle = class {
   shellActivity;
   onQuiescence;
   observeShellExit;
-  pid;
+  processId = 0;
+  get pid() {
+    return this.processId;
+  }
   output = new PassThrough();
   done;
   outcome = Promise.withResolvers();
@@ -95394,6 +95591,16 @@ var LocalTerminalHandle = class {
   managedRangeEmpty = !1;
   /** The spawned shell's start identity; scans stop adopting members once the root pid no longer carries it. */
   rootIdentity;
+  captureProcessIdentity() {
+    if (!(this.processId > 0 || this.exited || this.terminal.pid <= 0)) {
+      this.processId = this.terminal.pid;
+      try {
+        this.rootIdentity = this.inspector.snapshot().tree(this.processId).find((member) => member.pid === this.processId);
+      } catch {
+        this.rootIdentity = void 0;
+      }
+    }
+  }
   /** Whether node-pty has not yet published the top-level exit event. */
   get running() {
     return !this.exited;
@@ -95412,7 +95619,7 @@ var LocalTerminalHandle = class {
   // Local inspection is synchronous; the seam returns a promise for remote transports.
   // oxlint-disable-next-line typescript/require-await -- Preserve promise rejection semantics at the async provider contract.
   async inspectForeground() {
-    this.descendants(this.inspector.snapshot());
+    this.captureProcessIdentity(), this.descendants(this.inspector.snapshot());
     let processGroupId = this.inspector.foregroundPgid(this.pid);
     if (processGroupId !== void 0)
       return {
@@ -95422,6 +95629,7 @@ var LocalTerminalHandle = class {
   }
   // oxlint-disable-next-line typescript/require-await -- Local inspection is synchronous; SSH shares this promise interface.
   async inspectActivity() {
+    this.captureProcessIdentity();
     let state = this.quiescent ? "idle" : "unknown", revision = 0;
     if (!this.quiescent)
       try {
@@ -95482,7 +95690,7 @@ var LocalTerminalHandle = class {
    * event. This does not claim quiescence and does not replace terminate().
    */
   terminateForHostExit() {
-    this.forceStopDescendants(), this.forceStopShell(), this.forceStopDescendants(), this.managedOwner?.terminateForHostExit();
+    this.captureProcessIdentity(), this.forceStopDescendants(), this.forceStopShell(), this.forceStopDescendants(), this.managedOwner?.terminateForHostExit();
   }
   forceStopShell() {
     if (!this.exited) {
@@ -95597,6 +95805,12 @@ var LocalTerminalHandle = class {
     }
   }
   async closeOnce() {
+    if (this.platform === "win32" && this.processId === 0 && !this.exited) {
+      let deadline = Date.now() + 5e3;
+      for (; this.terminal.pid <= 0 && !this.exited && Date.now() < deadline; ) await delay(10);
+      if (this.captureProcessIdentity(), this.processId === 0 && !this.exited)
+        throw new Error("terminal cleanup failed; ConPTY process is not ready");
+    }
     if (this.managedOwner !== void 0) {
       try {
         await this.closeManagedRange(this.managedOwner), this.dataDisposable.dispose(), this.exitDisposable.dispose();
@@ -97756,6 +97970,7 @@ var FILE3 = "workspaces.json", Workspaces = class {
   referenceGroups;
   referenceProjectless = /* @__PURE__ */ new Set();
   referencePins;
+  referenceProjectRoots = /* @__PURE__ */ new Set();
   referenceArchives;
   save() {
     this.data.writeJson(FILE3, this.state);
@@ -97776,7 +97991,7 @@ var FILE3 = "workspaces.json", Workspaces = class {
     );
     return items.filter((workspace) => {
       let legacyReference = workspace.origin === void 0 && workspace.sessionIds.length > 0 && workspace.sessionIds.some((id) => references.has(id)) && workspace.sessionIds.every((id) => references.has(id) || id.startsWith("draft-"));
-      return workspace.origin === "web" || !(workspace.origin === "codexhost" || legacyReference) || allowedRoots.has(workspace.path);
+      return workspace.origin === "web" || !(workspace.origin === "codexhost" || legacyReference) || allowedRoots.has(workspace.path) || this.referenceProjectRoots.has(workspace.path);
     }).map((workspace) => ({
       ...workspace,
       sessionIds: workspace.sessionIds.filter(
@@ -97873,13 +98088,28 @@ var FILE3 = "workspaces.json", Workspaces = class {
     return title && workspace.origin !== "web" && workspace.title !== title && (workspace.title = title, this.touch(workspace)), workspace.sessionIds.includes(sessionId) || (workspace.sessionIds.push(sessionId), this.touch(workspace)), workspace;
   }
   /** Mirror one complete CH workspace snapshot, saving and publishing only final changes. */
-  syncReferencedSessions(sessions2, groups, projectless = /* @__PURE__ */ new Set()) {
+  syncReferencedSessions(sessions2, groups, projectless = /* @__PURE__ */ new Set(), projects = []) {
     let before = new Map(
       this.list().map((workspace) => [workspace.workspaceId, JSON.stringify(workspace)])
     ), items = this.state.items.map((workspace) => ({
       ...workspace,
       sessionIds: [...workspace.sessionIds]
-    })), byPath = new Map(items.map((workspace) => [workspace.path, workspace])), members = /* @__PURE__ */ new Map(), now = (/* @__PURE__ */ new Date()).toISOString();
+    })), byPath = new Map(items.map((workspace) => [workspace.path, workspace])), members = /* @__PURE__ */ new Map(), now = (/* @__PURE__ */ new Date()).toISOString(), projectRoots = /* @__PURE__ */ new Set();
+    for (let project2 of projects)
+      for (let root of project2.rootPaths) {
+        let path8 = resolve17(root);
+        projectRoots.add(path8);
+        let workspace = byPath.get(path8);
+        workspace ? workspace.origin !== "web" && (workspace.title = project2.name) : (workspace = {
+          workspaceId: randomUUID14(),
+          path: path8,
+          title: project2.name,
+          sessionIds: [],
+          createdAt: now,
+          updatedAt: now,
+          origin: "codexhost"
+        }, items.push(workspace), byPath.set(path8, workspace));
+      }
     for (let { sessionId, cwd, title } of sessions2) {
       let workspace = byPath.get(resolve17(cwd));
       if (!workspace) {
@@ -97914,7 +98144,7 @@ var FILE3 = "workspaces.json", Workspaces = class {
       let state = { ...this.state, items };
       this.data.writeJson(FILE3, state), this.state = state;
     }
-    this.referenceGroups = groups, this.referenceProjectless = projectless;
+    this.referenceProjectRoots = projectRoots, this.referenceGroups = groups, this.referenceProjectless = projectless;
     let after = this.list(), ids = new Set(after.map((workspace) => workspace.workspaceId));
     for (let workspaceId of before.keys())
       ids.has(workspaceId) || this.broadcast({ type: "remove", workspaceId });
@@ -98264,17 +98494,7 @@ var settings = new Settings(data, events), push = new PushNotifier(data);
 accessTokens !== void 0 && (push.retainOwners((owner) => owner === LOCAL_CREDENTIAL || accessTokens.has(owner)), accessTokens.onRevoked((id) => {
   connections.revoke(id), push.dropOwner(id);
 }));
-sessions.notifier = (notification) => {
-  push.notify({
-    kind: notification.kind,
-    title: notification.title,
-    body: notification.body,
-    tag: notification.sessionId,
-    sessionId: notification.sessionId,
-    url: `./?session=${encodeURIComponent(notification.sessionId)}`
-  });
-};
-var devWebUi = values["dev-web-ui"] === void 0 ? void 0 : resolve19(values["dev-web-ui"]), assetOptions = PACKED && devWebUi === void 0 ? {
+var pushNotifications = chHost.realtime ? new ChPushNotifications(chHost.realtime, push) : void 0, devWebUi = values["dev-web-ui"] === void 0 ? void 0 : resolve19(values["dev-web-ui"]), assetOptions = PACKED && devWebUi === void 0 ? {
   packedRoot: PACKED_WEB,
   plugins: [],
   globals: CLIENT_GLOBALS,
@@ -98649,7 +98869,7 @@ server.listen(Number(values.port), values.host, async () => {
   });
 });
 async function shutdown(exitCode = 0) {
-  relay.close(), shellReload?.close(), accessTokens?.close(), server.close(), desktopScreenshots.close(), await sidebarBrowser.close(), await dsh?.close(), await extensions2.cleanup(!0), await sessions.close(), await preferences?.close(), displaySettings.close(), process.exit(exitCode);
+  relay.close(), shellReload?.close(), accessTokens?.close(), server.close(), desktopScreenshots.close(), await sidebarBrowser.close(), await dsh?.close(), await extensions2.cleanup(!0), pushNotifications?.close(), await sessions.close(), await preferences?.close(), displaySettings.close(), process.exit(exitCode);
 }
 process.on("SIGINT", () => {
   shutdown();