@vibedeckx/linux-x64 0.3.14 → 0.3.17

package/dist/bin.js

@@ -186724,7 +186724,8 @@ var mapAgentSession = (row) => ({
   last_user_message_at: row.last_user_message_at,
   last_completed_at: row.last_completed_at,
   favorited_at: row.favorited_at,
-  native_session_id: row.native_session_id
+  native_session_id: row.native_session_id,
+  history_epoch: row.history_epoch
 });
 var parseActivityTimestamp = (value) => {
   const explicitZone = /(?:Z|[+-]\d\d:\d\d)$/i.test(value);
@@ -187123,6 +187124,11 @@ var createAgentSessionRepos = (kdb, h) => ({
     markCompleted: async (id, timestampMs) => {
       await kdb.updateTable("agent_sessions").set({ last_completed_at: timestampMs, activity_at: sql`max(activity_at, ${timestampMs})` }).where("id", "=", id).execute();
     },
+    incrementHistoryEpoch: async (id) => {
+      await kdb.updateTable("agent_sessions").set({ history_epoch: sql`history_epoch + 1` }).where("id", "=", id).execute();
+      const row = await kdb.selectFrom("agent_sessions").select("history_epoch").where("id", "=", id).executeTakeFirstOrThrow();
+      return row.history_epoch;
+    },
     delete: async (id) => {
       await kdb.deleteFrom("agent_sessions").where("id", "=", id).execute();
     },
@@ -203632,6 +203638,7 @@ var tightenWorkspaceCheckoutForeignKeys = (db) => {
           last_completed_at INTEGER DEFAULT NULL,
           favorited_at INTEGER DEFAULT NULL,
           native_session_id TEXT DEFAULT NULL,
+          history_epoch INTEGER NOT NULL DEFAULT 0,
           FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,
           FOREIGN KEY (workspace_checkout_id) REFERENCES workspace_checkouts(id)
             DEFERRABLE INITIALLY DEFERRED
@@ -203639,10 +203646,10 @@ var tightenWorkspaceCheckoutForeignKeys = (db) => {
         INSERT INTO agent_sessions_fk_new
           (id, project_id, branch, workspace_checkout_id, status, permission_mode, agent_type,
            title, model, created_at, updated_at, activity_at, last_user_message_at,
-           last_completed_at, favorited_at, native_session_id)
+           last_completed_at, favorited_at, native_session_id, history_epoch)
           SELECT id, project_id, branch, workspace_checkout_id, status, permission_mode, agent_type,
                  title, model, created_at, updated_at, activity_at, last_user_message_at,
-                 last_completed_at, favorited_at, native_session_id
+                 last_completed_at, favorited_at, native_session_id, history_epoch
             FROM agent_sessions;
         DROP TABLE agent_sessions;
         ALTER TABLE agent_sessions_fk_new RENAME TO agent_sessions;
@@ -203916,6 +203923,7 @@ var initializeSchema = (db) => {
       -- Drives the workspace-status derivation; see plans/branch-activity-refactor.md.
       last_user_message_at INTEGER DEFAULT NULL,
       last_completed_at INTEGER DEFAULT NULL,
+      history_epoch INTEGER NOT NULL DEFAULT 0,
       FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
     );
 
@@ -204450,6 +204458,10 @@ var initializeSchema = (db) => {
   if (!sessionInfoNativeId.some((col) => col.name === "native_session_id")) {
     db.exec("ALTER TABLE agent_sessions ADD COLUMN native_session_id TEXT DEFAULT NULL");
   }
+  const sessionHistoryEpochInfo = db.prepare("PRAGMA table_info(agent_sessions)").all();
+  if (!sessionHistoryEpochInfo.some((col) => col.name === "history_epoch")) {
+    db.exec("ALTER TABLE agent_sessions ADD COLUMN history_epoch INTEGER NOT NULL DEFAULT 0");
+  }
   const sessionCheckoutInfo = db.prepare("PRAGMA table_info(agent_sessions)").all();
   if (!sessionCheckoutInfo.some((col) => col.name === "workspace_checkout_id")) {
     db.exec("ALTER TABLE agent_sessions ADD COLUMN workspace_checkout_id TEXT DEFAULT NULL");
@@ -207067,6 +207079,7 @@ function buildApprovalResponse(requestId, decision) {
 
 // src/providers/codex-provider.ts
 var ITEM_PAYLOAD_SUMMARY_LIMIT = 500;
+var MAX_COMPLETED_TURN_IDS = 32;
 function firstText(...candidates) {
   for (const c of candidates) {
     if (typeof c === "string" && c.trim()) return c.trim();
@@ -207200,14 +207213,23 @@ var CodexProvider = class _CodexProvider {
   handleItemCompleted(params, sessionId) {
     const item = params?.item;
     if (!item?.type) return [];
-    if (params?.turnId != null) {
-      this.getSessionState(sessionId).currentTurnId = String(params.turnId);
-    }
+    const state = this.getSessionState(sessionId);
+    const itemTurnId = params?.turnId != null ? String(params.turnId) : null;
+    const outOfTurn = itemTurnId !== null && state.completedTurnIds.has(itemTurnId);
+    if (itemTurnId !== null && !outOfTurn) {
+      state.currentTurnId = itemTurnId;
+    }
+    const events = this.itemEvents(item, itemTurnId, outOfTurn, state);
+    if (!outOfTurn) return events;
+    return events.map(
+      (e) => e.type === "tool_use" || e.type === "tool_result" ? { ...e, outOfTurn: true } : e
+    );
+  }
+  itemEvents(item, itemTurnId, outOfTurn, state) {
     switch (item.type) {
       case "agentMessage": {
-        if (params?.turnId && (item.phase === "final_answer" || item.text)) {
-          const state = this.getSessionState(sessionId);
-          state.turnsWithFinalMessage.add(String(params.turnId));
+        if (itemTurnId && !outOfTurn && (item.phase === "final_answer" || item.text)) {
+          state.turnsWithFinalMessage.add(itemTurnId);
         }
         return [{ type: "text", content: item.text ?? "" }];
       }
@@ -207300,6 +207322,10 @@ var CodexProvider = class _CodexProvider {
     const hadFinalMessage = turnId != null && state.turnsWithFinalMessage.has(turnId);
     if (turnId != null) {
       state.turnsWithFinalMessage.delete(turnId);
+      state.completedTurnIds.add(turnId);
+      while (state.completedTurnIds.size > MAX_COMPLETED_TURN_IDS) {
+        state.completedTurnIds.delete(state.completedTurnIds.values().next().value);
+      }
     }
     state.currentTurnId = null;
     if (turn.status === "completed" && !hadFinalMessage) {
@@ -207424,7 +207450,8 @@ var CodexProvider = class _CodexProvider {
       pendingTurnContent: null,
       lastTokenUsage: {},
       turnsWithFinalMessage: /* @__PURE__ */ new Set(),
-      currentTurnId: null
+      currentTurnId: null,
+      completedTurnIds: /* @__PURE__ */ new Set()
     });
   }
   onSessionDestroyed(sessionId) {
@@ -207443,7 +207470,8 @@ var CodexProvider = class _CodexProvider {
         pendingTurnContent: null,
         lastTokenUsage: {},
         turnsWithFinalMessage: /* @__PURE__ */ new Set(),
-        currentTurnId: null
+        currentTurnId: null,
+        completedTurnIds: /* @__PURE__ */ new Set()
       };
       this.sessions.set(sessionId, state);
     }
@@ -229656,6 +229684,7 @@ var AgentSessionManager = class {
       process: null,
       dormant: false,
       processStartsInFlight: 0,
+      historyEpoch: stored?.history_epoch ?? 0,
       store,
       subscribers: /* @__PURE__ */ new Set(),
       status: "running",
@@ -230001,14 +230030,15 @@ var AgentSessionManager = class {
     if (!session) return;
     const timestamp = Date.now();
     session.lastActiveAt = timestamp;
-    if (event.type === "turn_started" || event.type === "text" || event.type === "thinking" || event.type === "tool_use" || event.type === "tool_result" || event.type === "approval_request") {
+    const outOfTurn = (event.type === "tool_use" || event.type === "tool_result") && event.outOfTurn === true;
+    if (!outOfTurn && (event.type === "turn_started" || event.type === "text" || event.type === "thinking" || event.type === "tool_use" || event.type === "tool_result" || event.type === "approval_request")) {
       this.applyCompletionTimerAction(session, session.completion.noteTurnActivity());
     }
-    if (session.turnOpenSince === null && (event.type === "turn_started" || event.type === "text" || event.type === "thinking" || event.type === "tool_use" || event.type === "tool_result" || event.type === "approval_request")) {
+    if (session.turnOpenSince === null && !outOfTurn && (event.type === "turn_started" || event.type === "text" || event.type === "thinking" || event.type === "tool_use" || event.type === "tool_result" || event.type === "approval_request")) {
       session.turnOpenSince = timestamp;
       session.turnDisposition = resolveNotificationDisposition(findLatestUserEntry(session.store.entries));
     }
-    if (session.status !== "running" && (event.type === "text" || event.type === "thinking" || event.type === "tool_use" || event.type === "tool_result" || event.type === "approval_request")) {
+    if (session.status !== "running" && !outOfTurn && (event.type === "text" || event.type === "thinking" || event.type === "tool_use" || event.type === "tool_result" || event.type === "approval_request")) {
       session.status = "running";
       if (!session.skipDb) await this.storage.agentSessions.updateStatus(sessionId, "running");
       this.broadcastPatch(sessionId, ConversationPatch.updateStatus("running"));
@@ -230497,17 +230527,29 @@ var AgentSessionManager = class {
   /**
    * Subscribe to session updates (WebSocket connection)
    */
-  subscribe(sessionId, ws) {
+  subscribe(sessionId, ws, opts = {}) {
     const session = this.sessions.get(sessionId);
     if (!session) {
       return null;
     }
     session.subscribers.add(ws);
+    const after = opts.historyEpoch === void 0 || opts.historyEpoch === session.historyEpoch ? opts.afterEntryIndex ?? -1 : -1;
+    ws.send(JSON.stringify({
+      HistorySync: {
+        historyEpoch: session.historyEpoch,
+        reset: opts.historyEpoch !== void 0 && opts.historyEpoch !== session.historyEpoch
+      }
+    }));
     for (const patch of session.store.patches) {
+      const entryIndices = patch.flatMap((op) => {
+        const match2 = op.path.match(/^\/entries\/(\d+)$/);
+        return match2 ? [Number(match2[1])] : [];
+      });
+      if (entryIndices.length > 0 && entryIndices.every((index) => index <= after)) continue;
       const msg = { JsonPatch: patch };
       ws.send(JSON.stringify(msg));
     }
-    ws.send(JSON.stringify({ Ready: true }));
+    ws.send(JSON.stringify({ Ready: true, historyEpoch: session.historyEpoch }));
     const statusPatch = ConversationPatch.updateStatus(session.status);
     ws.send(JSON.stringify({ JsonPatch: statusPatch }));
     return () => {
@@ -230525,6 +230567,9 @@ var AgentSessionManager = class {
   getRawMessages(sessionId) {
     return this.sessions.get(sessionId)?.store.entries ?? [];
   }
+  getHistoryEpoch(sessionId) {
+    return this.sessions.get(sessionId)?.historyEpoch;
+  }
   /**
    * Public wrapper over broadcastRaw for the WorkflowEngine: mirror a raw WS
    * frame to a session's stream subscribers (a front server subscribed to
@@ -230796,6 +230841,9 @@ var AgentSessionManager = class {
     this.emitProcessAlive(session, false);
     if (!session.skipDb) {
       await this.storage.agentSessions.deleteEntries(sessionId);
+      session.historyEpoch = await this.storage.agentSessions.incrementHistoryEpoch(sessionId);
+    } else {
+      session.historyEpoch += 1;
     }
     session.store.patches = [];
     session.store.entries = [];
@@ -230806,6 +230854,9 @@ var AgentSessionManager = class {
     session.dormant = false;
     session.turnOpenSince = null;
     this.touchSession(session);
+    this.broadcastRaw(sessionId, {
+      HistorySync: { historyEpoch: session.historyEpoch, reset: true }
+    });
     const clearPatch = ConversationPatch.clearAll();
     this.broadcastPatch(sessionId, clearPatch);
     session.status = "running";
@@ -231289,6 +231340,7 @@ var AgentSessionManager = class {
         process: null,
         dormant: true,
         processStartsInFlight: 0,
+        historyEpoch: dbSession.history_epoch ?? 0,
         store,
         subscribers: /* @__PURE__ */ new Set(),
         status: "stopped",
@@ -231310,10 +231362,59 @@ var AgentSessionManager = class {
       await this.storage.agentSessions.updateStatusPreservingTimestamp(dbSession.id, "stopped");
       restoredCount++;
     }
+    await this.repairOrphanedRunningRows(allSessions);
     if (restoredCount > 0) {
       console.log(`[AgentSession] Restored ${restoredCount} dormant session(s) from database`);
     }
   }
+  /**
+   * Reconcile rows the database still calls "running" against what this
+   * process actually owns.
+   *
+   * `create` writes `status='running'` BEFORE the process is spawned, so any
+   * path that dies between the INSERT and the first entry leaves a row
+   * claiming to run forever. The restore loop above is supposed to be the
+   * backstop, but it skips zero-entry rows before it resets crashed statuses
+   * — so precisely the sessions that died earliest are the ones nothing ever
+   * repairs. Measured on a real worker (2026-08-10): 63 such rows, the oldest
+   * four months old, every one of them permanently exempt from session
+   * retention (`status <> 'running'`) and inflating the project dashboard's
+   * running count (46 reported, 1 real).
+   *
+   * Reconciliation rather than prevention, deliberately: a DB row and an OS
+   * process are two resources with no atomic commit between them, so a kill
+   * landing between the INSERT and the spawn leaves the same row no matter
+   * how careful `create` becomes. Prevention narrows the window; only
+   * reconciliation closes it. Same argument the retention plan's §3.1 makes
+   * for snapshot reconciliation over delete events.
+   *
+   * The ownership test is "not in `this.sessions`", NOT `process === null`: a
+   * session that is spawning or waking sits in the map with a null process,
+   * and resetting it would be the same class of bug as the wake/retention
+   * race in `deleteDormantSessionIfExpired`.
+   *
+   * STARTUP ONLY. `createNewSession` INSERTs the row before it puts the
+   * session in the map, so a few milliseconds exist in which a perfectly
+   * healthy session looks orphaned. That window is unreachable from here (no
+   * requests are served yet); a periodic caller would first have to add an
+   * age threshold.
+   *
+   * @param snapshot the row list read at the top of `restoreSessionsFromDb`.
+   * Rows the loop already reset read as stale "running" here — the map check
+   * is what excludes them, which is why it must come after the loop.
+   */
+  async repairOrphanedRunningRows(snapshot) {
+    let repaired = 0;
+    for (const row of snapshot) {
+      if (row.status !== "running") continue;
+      if (this.sessions.has(row.id)) continue;
+      await this.storage.agentSessions.updateStatusPreservingTimestamp(row.id, "stopped");
+      repaired++;
+    }
+    if (repaired > 0) {
+      console.log(`[AgentSession] Reset ${repaired} orphaned session row(s) left as "running"`);
+    }
+  }
   /**
    * Create a new dormant session that copies another session's conversation
    * history ("branch"). The new session gets its own DB row, copied entry
@@ -231431,6 +231532,7 @@ var AgentSessionManager = class {
       process: null,
       dormant: true,
       processStartsInFlight: 0,
+      historyEpoch: 0,
       store,
       subscribers: /* @__PURE__ */ new Set(),
       status: "stopped",
@@ -232742,7 +232844,7 @@ async function persistRemoteSessionActivityFrame(storage, sessionId, remoteInfo,
   }
   return false;
 }
-function connectPersistentRemoteWs(sessionId, remoteInfo, cache2, reverseConnectManager, eventBus, agentSessionManager, storage) {
+function connectPersistentRemoteWs(sessionId, remoteInfo, cache2, reverseConnectManager, eventBus, agentSessionManager, storage, requestedHistory) {
   const hasCachedData = cache2.hasData(sessionId);
   console.log(`[AgentWS] Opening persistent remote WS for ${sessionId} (cached=${hasCachedData})`);
   if (!reverseConnectManager || !reverseConnectManager.isConnected(remoteInfo.remoteServerId)) {
@@ -232752,7 +232854,16 @@ function connectPersistentRemoteWs(sessionId, remoteInfo, cache2, reverseConnect
     return;
   }
   const channelId = randomUUID2();
-  const wsPath = `/api/agent-sessions/${remoteInfo.remoteSessionId}/stream`;
+  const cachedHead = cache2.get(sessionId);
+  const upstreamEpoch = requestedHistory?.historyEpoch ?? cachedHead?.historyEpoch ?? void 0;
+  const upstreamAfter = requestedHistory?.afterEntryIndex ?? (upstreamEpoch !== void 0 ? cachedHead?.lastTurnEndEntryIndex ?? void 0 : void 0);
+  const upstreamParams = new URLSearchParams();
+  if (upstreamEpoch !== void 0 && upstreamAfter !== void 0) {
+    upstreamParams.set("after", String(upstreamAfter));
+    upstreamParams.set("epoch", String(upstreamEpoch));
+  }
+  const usesBoundedReplay = upstreamParams.size > 0;
+  const wsPath = `/api/agent-sessions/${encodeURIComponent(remoteInfo.remoteSessionId)}/stream${usesBoundedReplay ? `?${upstreamParams}` : ""}`;
   const adapter = new VirtualWsAdapter(
     (data) => reverseConnectManager.sendChannelData(remoteInfo.remoteServerId, channelId, data),
     () => reverseConnectManager.closeChannel(remoteInfo.remoteServerId, channelId)
@@ -232786,6 +232897,7 @@ function connectPersistentRemoteWs(sessionId, remoteInfo, cache2, reverseConnect
       cache2.broadcast(sessionId, raw);
       const statusEvent = statusEventFromRemotePatch(parsed, sessionId, remoteInfo);
       if (statusEvent) {
+        cache2.setSessionStatus(sessionId, statusEvent.status);
         let activityReady = true;
         if (storage) {
           activityReady = await persistRemoteSessionActivityFrame(storage, sessionId, remoteInfo, parsed).catch((error48) => {
@@ -232802,6 +232914,11 @@ function connectPersistentRemoteWs(sessionId, remoteInfo, cache2, reverseConnect
       cache2.setFinished(sessionId);
       cache2.broadcast(sessionId, raw);
     } else if ("taskCompleted" in parsed) {
+      cache2.setSessionStatus(sessionId, "stopped");
+      const turnEndIndex = parsed.taskCompleted.turnEndEntryIndex;
+      if (typeof turnEndIndex === "number" && Number.isInteger(turnEndIndex)) {
+        cache2.setLastTurnEndEntryIndex(sessionId, turnEndIndex);
+      }
       cache2.appendMessage(sessionId, raw, false);
       cache2.broadcast(sessionId, raw);
       let activityReady = true;
@@ -232857,6 +232974,7 @@ function connectPersistentRemoteWs(sessionId, remoteInfo, cache2, reverseConnect
         }
       }
     } else if ("error" in parsed) {
+      cache2.setSessionStatus(sessionId, "error");
       cache2.appendMessage(sessionId, raw, false);
       cache2.broadcast(sessionId, raw);
       let activityReady = true;
@@ -232879,6 +232997,15 @@ function connectPersistentRemoteWs(sessionId, remoteInfo, cache2, reverseConnect
         cache2.setFinished(sessionId);
       }
     } else if ("Ready" in parsed) {
+      const epoch = parsed.historyEpoch;
+      if (typeof epoch === "number" && Number.isInteger(epoch)) cache2.setHistoryEpoch(sessionId, epoch);
+      cache2.broadcast(sessionId, raw);
+    } else if ("HistorySync" in parsed) {
+      const sync = parsed.HistorySync;
+      if (typeof sync.historyEpoch === "number" && Number.isInteger(sync.historyEpoch)) {
+        if (sync.reset === true) cache2.resetHistory(sessionId, sync.historyEpoch);
+        else cache2.setHistoryEpoch(sessionId, sync.historyEpoch);
+      }
       cache2.broadcast(sessionId, raw);
     }
   };
@@ -232917,8 +233044,12 @@ function connectPersistentRemoteWs(sessionId, remoteInfo, cache2, reverseConnect
         syncing = false;
         const currentEntry = cache2.get(sessionId);
         const cachedSeq = entryPatchFrames(currentEntry.messages);
-        const extendsCache = isSequencePrefix(cachedSeq, replayBuffer);
-        if (extendsCache && replayBuffer.length > cachedSeq.length) {
+        const extendsCache = !usesBoundedReplay && isSequencePrefix(cachedSeq, replayBuffer);
+        if (usesBoundedReplay) {
+          cache2.replaceEntryTail(sessionId, upstreamAfter, replayBuffer);
+          for (const msg of replayBuffer) cache2.broadcast(sessionId, msg);
+          cache2.broadcast(sessionId, raw);
+        } else if (extendsCache && replayBuffer.length > cachedSeq.length) {
           const delta = replayBuffer.slice(cachedSeq.length);
           console.log(`[AgentWS] Sync delta: ${delta.length} new entry patches for ${sessionId} (remote=${replayBuffer.length}, cached=${cachedSeq.length})`);
           for (const msg of delta) {
@@ -239313,6 +239444,24 @@ var EventBus = class {
 init_proxy_manager();
 
 // src/remote-patch-cache.ts
+function patchEntryMetadata(raw) {
+  let latest = null;
+  let lastTurnEnd = null;
+  try {
+    const parsed = JSON.parse(raw);
+    for (const op of parsed.JsonPatch ?? []) {
+      const match2 = op.path?.match(/^\/entries\/(\d+)$/);
+      if (!match2) continue;
+      const index = Number(match2[1]);
+      latest = Math.max(latest ?? -1, index);
+      if (op.value?.type === "ENTRY" && op.value.content?.type === "turn_end") {
+        lastTurnEnd = Math.max(lastTurnEnd ?? -1, index);
+      }
+    }
+  } catch {
+  }
+  return { latest, lastTurnEnd };
+}
 var RemotePatchCache = class {
   cache = /* @__PURE__ */ new Map();
   getOrCreate(sessionId) {
@@ -239326,7 +239475,11 @@ var RemotePatchCache = class {
         subscribers: /* @__PURE__ */ new Set(),
         reconnecting: false,
         reconnectTimer: null,
-        reconnectAttempt: 0
+        reconnectAttempt: 0,
+        historyEpoch: null,
+        latestEntryIndex: null,
+        lastTurnEndEntryIndex: null,
+        sessionStatus: null
       };
       this.cache.set(sessionId, entry);
     }
@@ -239349,6 +239502,11 @@ var RemotePatchCache = class {
     entry.messages.push(raw);
     if (isJsonPatch) {
       entry.patchCount++;
+      const metadata = patchEntryMetadata(raw);
+      if (metadata.latest !== null) entry.latestEntryIndex = Math.max(entry.latestEntryIndex ?? -1, metadata.latest);
+      if (metadata.lastTurnEnd !== null) {
+        entry.lastTurnEndEntryIndex = Math.max(entry.lastTurnEndEntryIndex ?? -1, metadata.lastTurnEnd);
+      }
     }
   }
   /** Full cache replacement (used when cache is detected as stale). */
@@ -239359,6 +239517,15 @@ var RemotePatchCache = class {
     const reconnecting = existing?.reconnecting ?? false;
     const reconnectTimer = existing?.reconnectTimer ?? null;
     const reconnectAttempt = existing?.reconnectAttempt ?? 0;
+    const historyEpoch = existing?.historyEpoch ?? null;
+    let latestEntryIndex = null;
+    let lastTurnEndEntryIndex = null;
+    for (const raw of messages) {
+      const metadata = patchEntryMetadata(raw);
+      if (metadata.latest !== null) latestEntryIndex = Math.max(latestEntryIndex ?? -1, metadata.latest);
+      if (metadata.lastTurnEnd !== null) lastTurnEndEntryIndex = Math.max(lastTurnEndEntryIndex ?? -1, metadata.lastTurnEnd);
+    }
+    const sessionStatus = existing?.sessionStatus ?? null;
     this.cache.set(sessionId, {
       messages,
       patchCount,
@@ -239367,8 +239534,43 @@ var RemotePatchCache = class {
       subscribers,
       reconnecting,
       reconnectTimer,
-      reconnectAttempt
+      reconnectAttempt,
+      historyEpoch,
+      latestEntryIndex,
+      lastTurnEndEntryIndex,
+      sessionStatus
+    });
+  }
+  /**
+   * Replace only the unsealed entry tail. Completed entries at or before the
+   * cursor and non-entry lifecycle frames stay cached; replayed tail frames
+   * become the authoritative copy after a tunnel reconnect.
+   */
+  replaceEntryTail(sessionId, afterEntryIndex, tail) {
+    const entry = this.getOrCreate(sessionId);
+    const kept = entry.messages.filter((raw) => {
+      try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed.JsonPatch)) return true;
+        const indices = parsed.JsonPatch.flatMap((op) => {
+          const match2 = op.path?.match(/^\/entries\/(\d+)$/);
+          return match2 ? [Number(match2[1])] : [];
+        });
+        return indices.length === 0 || indices.some((index) => index <= afterEntryIndex);
+      } catch {
+        return true;
+      }
     });
+    const messages = [...kept, ...tail];
+    const patchCount = messages.reduce((count, raw) => {
+      try {
+        const parsed = JSON.parse(raw);
+        return count + (Array.isArray(parsed.JsonPatch) ? 1 : 0);
+      } catch {
+        return count;
+      }
+    }, 0);
+    this.replaceAll(sessionId, messages, patchCount);
   }
   setFinished(sessionId) {
     const entry = this.cache.get(sessionId);
@@ -239376,6 +239578,25 @@ var RemotePatchCache = class {
       entry.finished = true;
     }
   }
+  setHistoryEpoch(sessionId, epoch) {
+    this.getOrCreate(sessionId).historyEpoch = epoch;
+  }
+  /** Start a fresh entry-index namespace without dropping live connections. */
+  resetHistory(sessionId, epoch) {
+    const entry = this.getOrCreate(sessionId);
+    entry.messages = [];
+    entry.patchCount = 0;
+    entry.finished = false;
+    entry.historyEpoch = epoch;
+    entry.latestEntryIndex = null;
+    entry.lastTurnEndEntryIndex = null;
+  }
+  setLastTurnEndEntryIndex(sessionId, index) {
+    this.getOrCreate(sessionId).lastTurnEndEntryIndex = index;
+  }
+  setSessionStatus(sessionId, status) {
+    this.getOrCreate(sessionId).sessionStatus = status;
+  }
   /** Store a persistent remote WebSocket connection. */
   setRemoteWs(sessionId, ws) {
     const entry = this.getOrCreate(sessionId);
@@ -239953,18 +240174,36 @@ var RemoteExecutorMonitor = class {
     this.eventBus = eventBus;
     this.storage = storage;
     this.remoteExecutorMap = remoteExecutorMap;
+    this.reverseConnectManager.setStatusChangeHandler((_remoteServerId, status) => {
+      if (status !== "online") return;
+      for (const [localProcessId, info] of this.watched) {
+        if (this.reverseConnectManager.isConnected(info.remoteServerId)) {
+          this.attach(localProcessId, info);
+        }
+      }
+    });
   }
   reverseConnectManager;
   eventBus;
   storage;
   remoteExecutorMap;
-  /** localProcessId → cleanup function */
-  monitors = /* @__PURE__ */ new Map();
+  /**
+   * Processes that still need a terminal observation.  This registry is
+   * deliberately separate from the currently-open virtual channels: a control
+   * connection can disappear while the remote process keeps running.
+   */
+  watched = /* @__PURE__ */ new Map();
+  /** localProcessId → cleanup for the currently-open virtual channel */
+  activeMonitors = /* @__PURE__ */ new Map();
   watch(localProcessId, remoteInfo) {
-    if (this.monitors.has(localProcessId)) return;
+    this.watched.set(localProcessId, remoteInfo);
+    this.attach(localProcessId, remoteInfo);
+  }
+  attach(localProcessId, remoteInfo) {
+    if (this.activeMonitors.has(localProcessId)) return;
     const rcm = this.reverseConnectManager;
     if (!rcm.isConnected(remoteInfo.remoteServerId)) {
-      console.log(`[RemoteExecutorMonitor] remote ${remoteInfo.remoteServerId} not connected for ${localProcessId}, skipping`);
+      console.log(`[RemoteExecutorMonitor] remote ${remoteInfo.remoteServerId} not connected for ${localProcessId}, deferring`);
       return;
     }
     const channelId = randomUUID8();
@@ -239977,11 +240216,16 @@ var RemoteExecutorMonitor = class {
     rcm.openVirtualChannel(remoteInfo.remoteServerId, channelId, wsPath);
     const remoteWs = adapter;
     setTimeout(() => adapter.emit("open"), 0);
-    const cleanup = () => {
-      this.monitors.delete(localProcessId);
-      try {
-        remoteWs.close();
-      } catch {
+    let cleanedUp = false;
+    const cleanupActive = (closeChannel) => {
+      if (cleanedUp) return;
+      cleanedUp = true;
+      this.activeMonitors.delete(localProcessId);
+      if (closeChannel) {
+        try {
+          remoteWs.close();
+        } catch {
+        }
       }
     };
     const outputChunks = [];
@@ -239992,7 +240236,10 @@ var RemoteExecutorMonitor = class {
           outputChunks.push(parsed.data);
         }
         if (parsed.type === "finished") {
+          this.watched.delete(localProcessId);
           const info = this.remoteExecutorMap.get(localProcessId);
+          const hasKnownExitCode = typeof parsed.exitCode === "number";
+          const eventExitCode = hasKnownExitCode ? parsed.exitCode : 1;
           if (info && !info.stoppedEmitted) {
             info.stoppedEmitted = true;
             let raw = outputChunks.join("");
@@ -240003,7 +240250,7 @@ var RemoteExecutorMonitor = class {
               projectId: info.projectId ?? "",
               executorId: info.executorId,
               processId: localProcessId,
-              exitCode: parsed.exitCode ?? 0,
+              exitCode: eventExitCode,
               target: info.remoteServerId,
               tailOutput,
               // Structured final message forwarded by the remote's finished
@@ -240012,33 +240259,33 @@ var RemoteExecutorMonitor = class {
             });
           }
           this.remoteExecutorMap.delete(localProcessId);
-          this.storage.remoteExecutorProcesses.markFinished(
-            localProcessId,
-            typeof parsed.exitCode === "number" ? parsed.exitCode : 0
-          ).catch((err) => {
+          const markFinished = hasKnownExitCode ? this.storage.remoteExecutorProcesses.markFinished(localProcessId, parsed.exitCode) : this.storage.remoteExecutorProcesses.markFinished(localProcessId, void 0, "killed");
+          markFinished.catch((err) => {
             console.error(`[RemoteExecutorMonitor] Failed to mark process ${localProcessId} finished:`, err);
           });
-          cleanup();
+          cleanupActive(true);
         }
       } catch {
       }
     });
     remoteWs.on("close", () => {
-      cleanup();
+      cleanupActive(false);
     });
     remoteWs.on("error", (error48) => {
       console.error(`[RemoteExecutorMonitor] error for ${localProcessId}:`, error48);
-      cleanup();
+      cleanupActive(true);
     });
-    this.monitors.set(localProcessId, cleanup);
+    this.activeMonitors.set(localProcessId, () => cleanupActive(true));
     console.log(`[RemoteExecutorMonitor] watching ${localProcessId}`);
   }
   unwatch(localProcessId) {
-    this.monitors.get(localProcessId)?.();
+    this.watched.delete(localProcessId);
+    this.activeMonitors.get(localProcessId)?.();
   }
   shutdown() {
-    for (const cleanup of this.monitors.values()) cleanup();
-    this.monitors.clear();
+    this.watched.clear();
+    for (const cleanup of [...this.activeMonitors.values()]) cleanup();
+    this.activeMonitors.clear();
   }
 };
 
@@ -245367,6 +245614,45 @@ var MODEL_SUGGESTIONS = {
   codex: ["gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna", "gpt-5.5"]
 };
 
+// src/session-history-window.ts
+function historyHead(entries, historyEpoch) {
+  let latestEntryIndex = null;
+  let lastTurnEndEntryIndex = null;
+  for (let index = entries.length - 1; index >= 0; index--) {
+    const message = entries[index];
+    if (!message) continue;
+    latestEntryIndex ??= index;
+    if (lastTurnEndEntryIndex === null && message.type === "turn_end") {
+      lastTurnEndEntryIndex = index;
+    }
+    if (latestEntryIndex !== null && lastTurnEndEntryIndex !== null) break;
+  }
+  return { historyEpoch, latestEntryIndex, lastTurnEndEntryIndex };
+}
+function buildHistoryWindow(entries, historyEpoch, opts = {}) {
+  const head = historyHead(entries, historyEpoch);
+  const endExclusive = Math.max(0, Math.min(opts.before ?? entries.length, entries.length));
+  const requestedTurns = Math.max(1, Math.min(opts.turns ?? 5, 20));
+  const boundaries = [];
+  for (let index = endExclusive - 1; index >= 0; index--) {
+    if (entries[index]?.type === "turn_end") boundaries.push(index);
+    if (boundaries.length >= requestedTurns + 2) break;
+  }
+  const startIndex = boundaries.length > requestedTurns + 1 ? boundaries[requestedTurns + 1] + 1 : 0;
+  const dense = [];
+  for (let index = startIndex; index < endExclusive; index++) {
+    const message = entries[index];
+    if (message) dense.push({ entryIndex: index, message });
+  }
+  const hasMore = startIndex > 0;
+  return {
+    ...head,
+    entries: dense,
+    previousCursor: hasMore ? startIndex : null,
+    hasMore
+  };
+}
+
 // src/routes/agent-session-routes.ts
 async function resolveProjectPath(projectId, storage) {
   if (projectId.startsWith("path:")) {
@@ -245517,7 +245803,7 @@ var routes11 = async (fastify2) => {
     return reply.code(200).send({ providers: providers2 });
   });
   fastify2.post("/api/path/agent-sessions", async (req, reply) => {
-    const { path: projectPath, branch, permissionMode, agentType, force, model } = req.body;
+    const { path: projectPath, branch, permissionMode, agentType, force, model, historyTurns } = req.body;
     if (!projectPath) {
       return reply.code(400).send({ error: "Path is required" });
     }
@@ -245555,6 +245841,8 @@ var routes11 = async (fastify2) => {
       }
       const session = fastify2.agentSessionManager.getSession(sessionId);
       const messages = fastify2.agentSessionManager.getMessages(sessionId);
+      const epoch = fastify2.agentSessionManager.getHistoryEpoch(sessionId) ?? 0;
+      const historyWindow = historyTurns ? buildHistoryWindow(fastify2.agentSessionManager.getRawMessages(sessionId), epoch, { turns: historyTurns }) : void 0;
       const projection = await fastify2.storage.agentSessions.getActivityById(sessionId, "session-detail");
       if (session?.workspaceCheckoutId && !projection) {
         return reply.code(409).send({
@@ -245579,7 +245867,8 @@ var routes11 = async (fastify2) => {
           checkoutDeletedAt: projection?.checkoutDeletedAt ?? null,
           processAlive: session ? fastify2.agentSessionManager.getSessionProcessAlive(sessionId) : false
         },
-        messages
+        messages: historyWindow ? historyWindow.entries.map((entry) => entry.message) : messages,
+        ...historyWindow ? { historyWindow } : {}
       });
     } catch (error48) {
       console.error("[API] Failed to load path-based agent session:", error48);
@@ -245866,7 +246155,7 @@ var routes11 = async (fastify2) => {
     if (!project) {
       return reply.code(404).send({ error: "Project not found" });
     }
-    const { branch, permissionMode, agentType, model } = req.body;
+    const { branch, permissionMode, agentType, model, historyTurns } = req.body;
     let agentMode = project.agent_mode;
     let useRemoteAgent = agentMode !== "local";
     if (useRemoteAgent && agentMode === "remote") {
@@ -245899,7 +246188,7 @@ var routes11 = async (fastify2) => {
           agentMode,
           "POST",
           `/api/path/agent-sessions`,
-          { path: remoteConfig.remote_path, branch, permissionMode, agentType, model }
+          { path: remoteConfig.remote_path, branch, permissionMode, agentType, model, historyTurns }
         );
         console.log(`[API] Remote proxy result: ok=${result.ok}, status=${result.status}, data=${JSON.stringify(result.data).substring(0, 500)}`);
         if (result.ok) {
@@ -245926,10 +246215,21 @@ var routes11 = async (fastify2) => {
           if (remoteData.messages && remoteData.messages.length > 0) {
             const cacheEntry = fastify2.remotePatchCache.getOrCreate(localSessionId);
             if (cacheEntry.messages.length === 0) {
-              for (let i = 0; i < remoteData.messages.length; i++) {
-                const patch = ConversationPatch.addEntry(i, remoteData.messages[i]);
+              const seededEntries = remoteData.historyWindow?.entries ?? remoteData.messages.map((message, entryIndex) => ({ entryIndex, message }));
+              for (const { entryIndex, message } of seededEntries) {
+                const patch = ConversationPatch.addEntry(entryIndex, message);
                 fastify2.remotePatchCache.appendMessage(localSessionId, JSON.stringify({ JsonPatch: patch }), true);
               }
+              if (remoteData.historyWindow) {
+                fastify2.remotePatchCache.setHistoryEpoch(localSessionId, remoteData.historyWindow.historyEpoch);
+                if (remoteData.historyWindow.lastTurnEndEntryIndex !== null) {
+                  fastify2.remotePatchCache.setLastTurnEndEntryIndex(localSessionId, remoteData.historyWindow.lastTurnEndEntryIndex);
+                }
+              }
+              const seededStatus = remoteData.session.status;
+              if (seededStatus === "running" || seededStatus === "stopped" || seededStatus === "error") {
+                fastify2.remotePatchCache.setSessionStatus(localSessionId, seededStatus);
+              }
               console.log(`[API] findExisting proxy: seeded cache with ${remoteData.messages.length} msgs for ${localSessionId}`);
             } else {
               console.log(`[API] findExisting proxy: cache already has ${cacheEntry.messages.length} msgs for ${localSessionId} (remote returned ${remoteData.messages.length}), skipping seed`);
@@ -245943,7 +246243,8 @@ var routes11 = async (fastify2) => {
               id: localSessionId,
               projectId: req.params.projectId
             },
-            messages: remoteData.messages
+            messages: remoteData.messages,
+            ...remoteData.historyWindow ? { historyWindow: remoteData.historyWindow } : {}
           });
         }
         return reply.code(proxyStatus(result)).send(result.data);
@@ -245968,6 +246269,8 @@ var routes11 = async (fastify2) => {
       }
       const session = fastify2.agentSessionManager.getSession(sessionId);
       const messages = fastify2.agentSessionManager.getMessages(sessionId);
+      const epoch = fastify2.agentSessionManager.getHistoryEpoch(sessionId) ?? 0;
+      const historyWindow = historyTurns ? buildHistoryWindow(fastify2.agentSessionManager.getRawMessages(sessionId), epoch, { turns: historyTurns }) : void 0;
       const effectiveStatus = session?.status || "stopped";
       return reply.code(200).send({
         session: {
@@ -245980,7 +246283,8 @@ var routes11 = async (fastify2) => {
           model: session?.model ?? null,
           processAlive: session ? fastify2.agentSessionManager.getSessionProcessAlive(sessionId) : false
         },
-        messages
+        messages: historyWindow ? historyWindow.entries.map((entry) => entry.message) : messages,
+        ...historyWindow ? { historyWindow } : {}
       });
     } catch (error48) {
       console.error("[API] Failed to load agent session:", error48);
@@ -246165,6 +246469,121 @@ var routes11 = async (fastify2) => {
       });
     }
   );
+  fastify2.get("/api/agent-sessions/:sessionId/history-window", async (req, reply) => {
+    const beforeRaw = req.query.before === void 0 ? void 0 : Number(req.query.before);
+    const turnsRaw = req.query.turns === void 0 ? void 0 : Number(req.query.turns);
+    const before = Number.isInteger(beforeRaw) && beforeRaw >= 0 ? beforeRaw : void 0;
+    const turns = Number.isInteger(turnsRaw) ? Math.max(1, Math.min(turnsRaw, 20)) : 5;
+    if (req.params.sessionId.startsWith("remote-")) {
+      const userId = requireUserFacingUserId(req, reply);
+      if (userId === null) return;
+      const remoteInfo = await getAuthorizedRemoteSessionInfo(req.params.sessionId, userId);
+      if (!remoteInfo) return reply.code(404).send({ error: "Remote session not found" });
+      const params = new URLSearchParams({ turns: String(turns) });
+      if (before !== void 0) params.set("before", String(before));
+      const result = await proxyAuto(
+        remoteInfo.remoteServerId,
+        "GET",
+        `/api/agent-sessions/${encodeURIComponent(remoteInfo.remoteSessionId)}/history-window?${params}`
+      );
+      if (result.ok) {
+        const data = result.data;
+        return reply.code(200).send({
+          ...data,
+          session: data.session ? {
+            ...data.session,
+            id: req.params.sessionId,
+            projectId: projectIdFromRemoteSessionId(req.params.sessionId, remoteInfo),
+            branch: remoteInfo.branch ?? null
+          } : void 0
+        });
+      }
+      if (result.status === 404) {
+        const legacy = await proxyAuto(
+          remoteInfo.remoteServerId,
+          "GET",
+          `/api/agent-sessions/${encodeURIComponent(remoteInfo.remoteSessionId)}`
+        );
+        if (!legacy.ok) return reply.code(proxyStatus(legacy)).send(legacy.data);
+        const data = legacy.data;
+        const messages = data.messages ?? [];
+        return reply.code(200).send({
+          ...buildHistoryWindow(messages, 0, { before, turns }),
+          status: data.session?.status ?? "stopped",
+          legacyFallback: true
+        });
+      }
+      return reply.code(proxyStatus(result)).send(result.data);
+    }
+    const session = fastify2.agentSessionManager.getSession(req.params.sessionId);
+    if (!session) return reply.code(404).send({ error: "Session not found" });
+    const epoch = fastify2.agentSessionManager.getHistoryEpoch(req.params.sessionId) ?? 0;
+    return reply.code(200).send({
+      ...buildHistoryWindow(fastify2.agentSessionManager.getRawMessages(req.params.sessionId), epoch, { before, turns }),
+      status: session.status,
+      session: {
+        id: session.id,
+        projectId: session.projectId,
+        branch: session.branch,
+        status: session.status,
+        permissionMode: session.permissionMode,
+        agentType: session.agentType,
+        model: session.model,
+        processAlive: fastify2.agentSessionManager.getSessionProcessAlive(session.id)
+      }
+    });
+  });
+  fastify2.get(
+    "/api/agent-sessions/:sessionId/history-head",
+    async (req, reply) => {
+      if (req.params.sessionId.startsWith("remote-")) {
+        const userId = requireUserFacingUserId(req, reply);
+        if (userId === null) return;
+        const remoteInfo = await getAuthorizedRemoteSessionInfo(req.params.sessionId, userId);
+        if (!remoteInfo) return reply.code(404).send({ error: "Remote session not found" });
+        const cached2 = fastify2.remotePatchCache.get(req.params.sessionId);
+        if (cached2?.historyEpoch !== null && cached2?.lastTurnEndEntryIndex !== null && cached2?.sessionStatus) {
+          return reply.code(200).send({
+            historyEpoch: cached2.historyEpoch,
+            latestEntryIndex: cached2.latestEntryIndex,
+            lastTurnEndEntryIndex: cached2.lastTurnEndEntryIndex,
+            status: cached2.sessionStatus
+          });
+        }
+        const result = await proxyAuto(
+          remoteInfo.remoteServerId,
+          "GET",
+          `/api/agent-sessions/${encodeURIComponent(remoteInfo.remoteSessionId)}/history-head`
+        );
+        if (result.ok) return reply.code(200).send(result.data);
+        if (result.status !== 404) return reply.code(proxyStatus(result)).send(result.data);
+        const legacy = await proxyAuto(
+          remoteInfo.remoteServerId,
+          "GET",
+          `/api/agent-sessions/${encodeURIComponent(remoteInfo.remoteSessionId)}`
+        );
+        if (!legacy.ok) return reply.code(proxyStatus(legacy)).send(legacy.data);
+        const data = legacy.data;
+        const head2 = buildHistoryWindow(data.messages ?? [], 0, { turns: 1 });
+        return reply.code(200).send({
+          historyEpoch: head2.historyEpoch,
+          latestEntryIndex: head2.latestEntryIndex,
+          lastTurnEndEntryIndex: head2.lastTurnEndEntryIndex,
+          status: data.session?.status ?? "stopped"
+        });
+      }
+      const session = fastify2.agentSessionManager.getSession(req.params.sessionId);
+      if (!session) return reply.code(404).send({ error: "Session not found" });
+      const epoch = fastify2.agentSessionManager.getHistoryEpoch(req.params.sessionId) ?? 0;
+      const head = buildHistoryWindow(fastify2.agentSessionManager.getRawMessages(req.params.sessionId), epoch, { turns: 1 });
+      return reply.code(200).send({
+        historyEpoch: head.historyEpoch,
+        latestEntryIndex: head.latestEntryIndex,
+        lastTurnEndEntryIndex: head.lastTurnEndEntryIndex,
+        status: session.status
+      });
+    }
+  );
   fastify2.get(
     "/api/agent-sessions/:sessionId/brief-source",
     async (req, reply) => {
@@ -249434,6 +249853,13 @@ function attachWsHeartbeat(socket, { label, intervalMs = DEFAULT_INTERVAL_MS, ke
 }
 
 // src/routes/websocket-routes.ts
+function resolveRemoteReplayCursor(clientEpoch, cachedEpoch, afterEntryIndex) {
+  const epochMatches = clientEpoch === void 0 || cachedEpoch !== null && clientEpoch === cachedEpoch;
+  return {
+    epochMatches,
+    replayAfter: epochMatches ? afterEntryIndex ?? -1 : -1
+  };
+}
 var routes23 = async (fastify2) => {
   fastify2.reverseConnectManager.setStatusChangeHandler((remoteServerId, status) => {
     if (status !== "online") return;
@@ -249645,6 +250071,8 @@ var routes23 = async (fastify2) => {
       { websocket: true },
       async (socket, req) => {
         const { sessionId } = req.params;
+        const afterEntryIndex = Number.isInteger(Number(req.query.after)) ? Number(req.query.after) : void 0;
+        const historyEpoch = Number.isInteger(Number(req.query.epoch)) ? Number(req.query.epoch) : void 0;
         console.log(`[AgentWS] Connection attempt for session ${sessionId} (auth=${fastify2.authEnabled})`);
         let principalUserId = fastify2.authEnabled ? null : "local";
         if (fastify2.authEnabled) {
@@ -249694,15 +250122,42 @@ var routes23 = async (fastify2) => {
           const cacheEntry = cache2.getOrCreate(sessionId);
           console.log(`[AgentWS] WS connect: cacheEntry for ${sessionId} has messages.length=${cacheEntry.messages.length} finished=${cacheEntry.finished} remoteWsOpen=${!!cache2.getRemoteWs(sessionId)}`);
           if (cacheEntry.messages.length > 0) {
-            console.log(`[AgentWS] Replaying ${cacheEntry.messages.length} cached msgs for ${sessionId}`);
+            const { epochMatches, replayAfter } = resolveRemoteReplayCursor(
+              historyEpoch,
+              cacheEntry.historyEpoch,
+              afterEntryIndex
+            );
+            console.log(`[AgentWS] Replaying cached msgs for ${sessionId} after=${replayAfter}`);
+            try {
+              socket.send(JSON.stringify({
+                HistorySync: {
+                  historyEpoch: cacheEntry.historyEpoch ?? historyEpoch ?? 0,
+                  reset: !epochMatches
+                }
+              }));
+            } catch {
+            }
             for (const raw of cacheEntry.messages) {
+              if (replayAfter >= 0) {
+                try {
+                  const parsed = JSON.parse(raw);
+                  if (Array.isArray(parsed.JsonPatch)) {
+                    const indices = parsed.JsonPatch.flatMap((op) => {
+                      const match2 = op.path?.match(/^\/entries\/(\d+)$/);
+                      return match2 ? [Number(match2[1])] : [];
+                    });
+                    if (indices.length > 0 && indices.every((index) => index <= replayAfter)) continue;
+                  }
+                } catch {
+                }
+              }
               try {
                 socket.send(raw);
               } catch {
               }
             }
             try {
-              socket.send(JSON.stringify({ Ready: true }));
+              socket.send(JSON.stringify({ Ready: true, historyEpoch: cacheEntry.historyEpoch ?? void 0 }));
             } catch {
             }
             if (cacheEntry.finished) {
@@ -249728,7 +250183,8 @@ var routes23 = async (fastify2) => {
               fastify2.reverseConnectManager,
               fastify2.eventBus,
               fastify2.agentSessionManager,
-              fastify2.storage
+              fastify2.storage,
+              { afterEntryIndex, historyEpoch }
             );
           }
           if (cache2.getRemoteWs(sessionId)) {
@@ -249758,7 +250214,7 @@ var routes23 = async (fastify2) => {
           });
           return;
         }
-        const unsubscribe = fastify2.agentSessionManager.subscribe(sessionId, socket);
+        const unsubscribe = fastify2.agentSessionManager.subscribe(sessionId, socket, { afterEntryIndex, historyEpoch });
         if (!unsubscribe) {
           console.log(`[AgentWS] Session ${sessionId} not found`);
           stopHeartbeat();
@@ -253437,6 +253893,8 @@ var WORKER_CAPABILITIES = {
   "http:POST /api/path/agent-sessions": { since: "0.2.0", summary: "\u521B\u5EFA\u4F1A\u8BDD" },
   "http:POST /api/path/agent-sessions/new": { since: "0.2.0", summary: "\u521B\u5EFA\u4F1A\u8BDD(\u6307\u5B9A ID)" },
   "http:GET /api/agent-sessions/:param": { since: "0.2.0", summary: "\u8BFB\u4F1A\u8BDD\u8BE6\u60C5/\u5BF9\u8BDD" },
+  "http:GET /api/agent-sessions/:param/history-window": { since: "0.4.0", summary: "\u6309 turn \u8FB9\u754C\u8BFB\u53D6\u4F1A\u8BDD\u7A97\u53E3" },
+  "http:GET /api/agent-sessions/:param/history-head": { since: "0.4.0", summary: "\u8BFB\u53D6\u4F1A\u8BDD\u5386\u53F2\u6E38\u6807" },
   // Additive: a worker below 0.3.6 404s it and the hub's intent-brief
   // distillation degrades to the deterministic excerpt (tier 2).
   "http:GET /api/agent-sessions/:param/brief-source": { since: "0.3.6", summary: "\u8BFB\u4F1A\u8BDD\u5BF9\u8BDD(\u4EC5\u84B8\u998F\u7528\u6587\u672C)" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibedeckx/linux-x64",
-  "version": "0.3.14",
+  "version": "0.3.17",
   "description": "Vibedeckx platform binaries for Linux x64",
   "os": [
     "linux"