@vibedeckx/linux-x64 0.2.2 → 0.2.3

package/dist/bin.js

@@ -9400,7 +9400,7 @@ var require_InstrumentDescriptor = __commonJS({
     var api_1 = (init_esm(), __toCommonJS(esm_exports));
     var utils_1 = require_utils5();
     function createInstrumentDescriptor(name25, type, options) {
-      if (!isValidName(name25)) {
+      if (!isValidName2(name25)) {
         api_1.diag.warn(`Invalid metric name: "${name25}". The metric name should be a ASCII string with a length no greater than 255 characters.`);
       }
       return {
@@ -9429,10 +9429,10 @@ var require_InstrumentDescriptor = __commonJS({
     }
     exports.isDescriptorCompatibleWith = isDescriptorCompatibleWith;
     var NAME_REGEXP = /^[a-z][a-z0-9_.\-/]{0,254}$/i;
-    function isValidName(name25) {
+    function isValidName2(name25) {
       return NAME_REGEXP.test(name25);
     }
-    exports.isValidName = isValidName;
+    exports.isValidName = isValidName2;
   }
 });
 
@@ -185912,6 +185912,217 @@ var createCrossRemoteAuditRepo = (kdb) => ({
   }
 });
 
+// src/storage/repositories/merge-targets.ts
+var createMergeTargetsRepo = (kdb) => ({
+  mergeTargets: {
+    getForBranches: async (projectId, branches) => {
+      if (branches.length === 0) return /* @__PURE__ */ new Map();
+      const rows = await kdb.selectFrom("branch_merge_targets").select(["branch", "target"]).where("project_id", "=", projectId).where("branch", "in", branches).execute();
+      return new Map(rows.map((row) => [row.branch, row.target]));
+    },
+    upsert: async (projectId, branch, target) => {
+      const result = await kdb.insertInto("branch_merge_targets").values({ project_id: projectId, branch, target }).onConflict(
+        (conflict) => conflict.columns(["project_id", "branch"]).doUpdateSet({
+          target,
+          updated_at: (/* @__PURE__ */ new Date()).toISOString()
+        }).where("target", "!=", target)
+      ).executeTakeFirst();
+      return (result.numInsertedOrUpdatedRows ?? 0n) > 0n;
+    },
+    insertIfAbsent: async (projectId, branch, target) => {
+      const result = await kdb.insertInto("branch_merge_targets").values({ project_id: projectId, branch, target }).onConflict((conflict) => conflict.columns(["project_id", "branch"]).doNothing()).executeTakeFirst();
+      return (result.numInsertedOrUpdatedRows ?? 0n) > 0n;
+    },
+    delete: async (projectId, branch) => {
+      const result = await kdb.deleteFrom("branch_merge_targets").where("project_id", "=", projectId).where("branch", "=", branch).executeTakeFirst();
+      return result.numDeletedRows > 0n;
+    }
+  }
+});
+
+// src/storage/repositories/search-cache.ts
+var toDbBranch = (branch) => branch ?? "";
+var fromDbBranch = (branch) => branch === "" ? null : branch;
+var escapeLike = (s3) => s3.replace(/[\\%_]/g, (c) => `\\${c}`);
+var matchTier = (text2, q) => {
+  if (!q) return 2;
+  if (!text2) return 3;
+  const t = text2.toLowerCase();
+  if (t === q) return 0;
+  if (t.startsWith(q)) return 1;
+  if (t.includes(q)) return 2;
+  return 3;
+};
+var parseDbTimestamp = (ts) => {
+  if (!ts) return null;
+  const ms = Date.parse(ts.replace(" ", "T") + "Z");
+  return Number.isNaN(ms) ? null : ms;
+};
+var rankAndCap = (items, limit) => items.filter((x2) => x2.tier < 3).sort((a, b2) => a.tier - b2.tier || Number(b2.favorited) - Number(a.favorited) || b2.recency - a.recency).slice(0, limit).map((x2) => x2.item);
+var createSearchCacheRepos = (kdb, _h) => ({
+  searchCache: {
+    // Generation-based reconciliation: only a FULLY successful snapshot may
+    // mark rows deleted. Runs in one transaction so a crash mid-apply can't
+    // leave a half-deleted cache.
+    applyCatalogSnapshot: async (projectId, targetId, snapshot) => {
+      const now2 = Date.now();
+      await kdb.transaction().execute(async (trx) => {
+        const state = await trx.selectFrom("search_catalog_sync_state").select("snapshot_generation").where("project_id", "=", projectId).where("target_id", "=", targetId).executeTakeFirst();
+        const generation = (state?.snapshot_generation ?? 0) + 1;
+        for (const w2 of snapshot.workspaces) {
+          await trx.insertInto("workspace_search_cache").values({ project_id: projectId, target_id: targetId, branch: toDbBranch(w2.branch), generation, deleted_at: null }).onConflict((oc) => oc.columns(["project_id", "target_id", "branch"]).doUpdateSet({ generation, deleted_at: null })).execute();
+        }
+        for (const s3 of snapshot.sessions) {
+          await trx.insertInto("session_search_cache").values({
+            local_session_id: s3.id,
+            project_id: projectId,
+            target_id: targetId,
+            branch: toDbBranch(s3.branch),
+            title: s3.title,
+            last_active_at: s3.lastActiveAt,
+            favorited_at: s3.favoritedAt,
+            entry_count: s3.entryCount,
+            generation,
+            deleted_at: null
+          }).onConflict((oc) => oc.column("local_session_id").doUpdateSet({
+            project_id: projectId,
+            target_id: targetId,
+            branch: toDbBranch(s3.branch),
+            title: s3.title,
+            last_active_at: s3.lastActiveAt,
+            favorited_at: s3.favoritedAt,
+            entry_count: s3.entryCount,
+            generation,
+            deleted_at: null
+          })).execute();
+        }
+        await trx.updateTable("workspace_search_cache").set({ deleted_at: now2 }).where("project_id", "=", projectId).where("target_id", "=", targetId).where("generation", "<", generation).where("deleted_at", "is", null).execute();
+        await trx.updateTable("session_search_cache").set({ deleted_at: now2 }).where("project_id", "=", projectId).where("target_id", "=", targetId).where("generation", "<", generation).where("deleted_at", "is", null).execute();
+        await trx.insertInto("search_catalog_sync_state").values({
+          project_id: projectId,
+          target_id: targetId,
+          last_success_at: now2,
+          last_attempt_at: now2,
+          snapshot_generation: generation,
+          last_error: null
+        }).onConflict((oc) => oc.columns(["project_id", "target_id"]).doUpdateSet({
+          last_success_at: now2,
+          last_attempt_at: now2,
+          snapshot_generation: generation,
+          last_error: null
+        })).execute();
+      });
+    },
+    recordSyncFailure: async (projectId, targetId, error48) => {
+      const now2 = Date.now();
+      await kdb.insertInto("search_catalog_sync_state").values({
+        project_id: projectId,
+        target_id: targetId,
+        last_success_at: null,
+        last_attempt_at: now2,
+        snapshot_generation: 0,
+        last_error: error48
+      }).onConflict((oc) => oc.columns(["project_id", "target_id"]).doUpdateSet({ last_attempt_at: now2, last_error: error48 })).execute();
+    },
+    getSyncStates: async (projectIds) => {
+      if (projectIds.length === 0) return [];
+      return kdb.selectFrom("search_catalog_sync_state").select(["project_id", "target_id", "last_success_at", "last_attempt_at", "last_error"]).where("project_id", "in", projectIds).execute();
+    },
+    // Opportunistic freshness: called where a title transits the server
+    // anyway (remote title PATCH proxy). UPDATE-only — inserting here would
+    // fabricate a row outside snapshot generations.
+    updateCachedSessionTitle: async (localSessionId, title) => {
+      await kdb.updateTable("session_search_cache").set({ title }).where("local_session_id", "=", localSessionId).execute();
+    },
+    search: async ({ userId, query, limitPerGroup }) => {
+      const q = query.trim().slice(0, 256).toLowerCase();
+      let projQuery = kdb.selectFrom("projects").select(["id", "name", "path"]).where("id", "not like", "path:%");
+      if (userId) projQuery = projQuery.where("user_id", "=", userId);
+      const allProjects = await projQuery.execute();
+      const projectIds = allProjects.map((p2) => p2.id);
+      const nameById = new Map(allProjects.map((p2) => [p2.id, p2.name]));
+      if (projectIds.length === 0) return { projects: [], workspaces: [], sessions: [] };
+      const pattern = `%${escapeLike(q)}%`;
+      let localBase = kdb.selectFrom("agent_sessions as s").select(["s.id", "s.project_id", "s.branch", "s.title", "s.last_user_message_at", "s.updated_at", "s.favorited_at"]).where("s.project_id", "in", projectIds).where((eb) => eb.or([
+        eb("s.title", "is not", null),
+        eb.exists(
+          eb.selectFrom("agent_session_entries").select("agent_session_entries.session_id").whereRef("agent_session_entries.session_id", "=", "s.id")
+        )
+      ]));
+      if (q) localBase = localBase.where(sql`lower(coalesce(s.title, '')) like ${pattern} escape '\\'`);
+      const localRows = await localBase.orderBy("s.updated_at", "desc").limit(200).execute();
+      const localFavRows = await localBase.where("s.favorited_at", "is not", null).execute();
+      let cacheBase = kdb.selectFrom("session_search_cache as c").leftJoin("project_remotes as pr", (join2) => join2.onRef("pr.project_id", "=", "c.project_id").onRef("pr.remote_server_id", "=", "c.target_id")).select(["c.local_session_id", "c.project_id", "c.target_id", "c.branch", "c.title", "c.last_active_at", "c.favorited_at"]).where("c.project_id", "in", projectIds).where("c.deleted_at", "is", null).where((eb) => eb.or([
+        eb("c.target_id", "=", "local"),
+        eb("pr.id", "is not", null)
+      ]));
+      if (q) cacheBase = cacheBase.where(sql`lower(coalesce(c.title, '')) like ${pattern} escape '\\'`);
+      const cacheRows = await cacheBase.orderBy("c.last_active_at", "desc").limit(200).execute();
+      const cacheFavRows = await cacheBase.where("c.favorited_at", "is not", null).execute();
+      const candidateById = /* @__PURE__ */ new Map();
+      for (const r of [...localRows, ...localFavRows]) {
+        if (candidateById.has(r.id)) continue;
+        candidateById.set(r.id, {
+          sessionId: r.id,
+          projectId: r.project_id,
+          projectName: nameById.get(r.project_id) ?? "",
+          targetId: "local",
+          branch: fromDbBranch(r.branch),
+          title: r.title ?? null,
+          lastActiveAt: r.last_user_message_at ?? parseDbTimestamp(r.updated_at),
+          favoritedAt: r.favorited_at ?? null
+        });
+      }
+      for (const r of [...cacheRows, ...cacheFavRows]) {
+        if (candidateById.has(r.local_session_id)) continue;
+        candidateById.set(r.local_session_id, {
+          sessionId: r.local_session_id,
+          projectId: r.project_id,
+          projectName: nameById.get(r.project_id) ?? "",
+          targetId: r.target_id,
+          branch: fromDbBranch(r.branch),
+          title: r.title ?? null,
+          lastActiveAt: r.last_active_at ?? null,
+          favoritedAt: r.favorited_at ?? null
+        });
+      }
+      const sessionCandidates = [...candidateById.values()];
+      if (!q) {
+        const sessions2 = [...sessionCandidates].sort((a, b2) => Number(!!b2.favoritedAt) - Number(!!a.favoritedAt) || (b2.lastActiveAt ?? 0) - (a.lastActiveAt ?? 0)).slice(0, limitPerGroup);
+        return { projects: [], workspaces: [], sessions: sessions2 };
+      }
+      const projects = rankAndCap(allProjects.map((p2) => ({
+        item: { id: p2.id, name: p2.name, path: p2.path ?? null },
+        tier: Math.min(matchTier(p2.name, q), matchTier(p2.path, q)),
+        favorited: false,
+        recency: 0
+      })), limitPerGroup);
+      const wsRows = await kdb.selectFrom("workspace_search_cache as w").leftJoin("project_remotes as pr", (join2) => join2.onRef("pr.project_id", "=", "w.project_id").onRef("pr.remote_server_id", "=", "w.target_id")).select(["w.project_id", "w.target_id", "w.branch"]).where("w.project_id", "in", projectIds).where("w.deleted_at", "is", null).where((eb) => eb.or([
+        eb("w.target_id", "=", "local"),
+        eb("pr.id", "is not", null)
+      ])).execute();
+      const workspaces = rankAndCap(wsRows.map((w2) => ({
+        item: {
+          projectId: w2.project_id,
+          projectName: nameById.get(w2.project_id) ?? "",
+          targetId: w2.target_id,
+          branch: fromDbBranch(w2.branch)
+        },
+        tier: matchTier(fromDbBranch(w2.branch) ?? "main", q),
+        favorited: false,
+        recency: 0
+      })), limitPerGroup);
+      const sessions = rankAndCap(sessionCandidates.map((s3) => ({
+        item: s3,
+        tier: matchTier(s3.title, q),
+        favorited: !!s3.favoritedAt,
+        recency: s3.lastActiveAt ?? 0
+      })), limitPerGroup);
+      return { projects, workspaces, sessions };
+    }
+  }
+});
+
 // src/storage/sqlite.ts
 var createDatabase = (dbPath) => {
   const db = new Database(dbPath);
@@ -186534,6 +186745,54 @@ var createDatabase = (dbPath) => {
   if (!scheduledRunCols.some((c) => c.name === "report")) {
     db.exec("ALTER TABLE scheduled_task_runs ADD COLUMN report TEXT DEFAULT NULL");
   }
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS branch_merge_targets (
+      project_id TEXT NOT NULL,
+      branch TEXT NOT NULL,
+      target TEXT NOT NULL,
+      updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+      PRIMARY KEY (project_id, branch),
+      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+    );
+
+    -- Search caches: server-side searchable copies of worker catalogs.
+    -- remote_session_mappings stays routing-only; these tables are reconciled
+    -- from full catalog snapshots (generation-based) and rows are soft-deleted,
+    -- so wiping them never breaks existing remote session URLs.
+    CREATE TABLE IF NOT EXISTS session_search_cache (
+      local_session_id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL,
+      target_id TEXT NOT NULL,
+      branch TEXT NOT NULL DEFAULT '',
+      title TEXT,
+      last_active_at INTEGER,
+      favorited_at INTEGER,
+      entry_count INTEGER NOT NULL DEFAULT 0,
+      generation INTEGER NOT NULL,
+      deleted_at INTEGER
+    );
+    CREATE INDEX IF NOT EXISTS idx_session_search_cache_project
+      ON session_search_cache(project_id, target_id);
+
+    CREATE TABLE IF NOT EXISTS workspace_search_cache (
+      project_id TEXT NOT NULL,
+      target_id TEXT NOT NULL,
+      branch TEXT NOT NULL,
+      generation INTEGER NOT NULL,
+      deleted_at INTEGER,
+      PRIMARY KEY (project_id, target_id, branch)
+    );
+
+    CREATE TABLE IF NOT EXISTS search_catalog_sync_state (
+      project_id TEXT NOT NULL,
+      target_id TEXT NOT NULL,
+      last_success_at INTEGER,
+      last_attempt_at INTEGER,
+      snapshot_generation INTEGER NOT NULL DEFAULT 0,
+      last_error TEXT,
+      PRIMARY KEY (project_id, target_id)
+    );
+  `);
   db.pragma("foreign_keys = ON");
   return db;
 };
@@ -186550,6 +186809,8 @@ var createSqliteStorage = async (dbPath) => {
     ...createAgentSessionRepos(kdb, h),
     ...createWorkspaceRepos(kdb, h),
     ...createCrossRemoteAuditRepo(kdb),
+    ...createMergeTargetsRepo(kdb),
+    ...createSearchCacheRepos(kdb, h),
     close: async () => {
       await kdb.destroy();
     }
@@ -223964,7 +224225,8 @@ var AgentSessionManager = class {
       eventChain: Promise.resolve(),
       bgSpawnHintsThisTurn: 0,
       taskStartedThisTurn: 0,
-      lastActiveAt: Date.now()
+      lastActiveAt: Date.now(),
+      turnOpenSince: null
     };
     this.sessions.set(sessionId, session);
     const provider = getProvider(agentType);
@@ -224104,21 +224366,26 @@ var AgentSessionManager = class {
         if (action.kind === "commit") {
           await this.commitCompletion(session, action.payload);
         }
+        if (code !== 0 && !spawnFailed && !session.producedOutput) {
+          try {
+            await this.pushEntry(session.id, {
+              type: "error",
+              message: this.buildStartupFailureMessage(session.agentType, stderrTail),
+              timestamp: Date.now()
+            }, true);
+          } catch (err) {
+            console.error(`[AgentSession] Failed to push startup-failure entry for ${session.id}:`, err);
+          }
+        }
+        await this.finalizeStreamingEntry(session);
+        session.store.currentAssistantIndex = null;
+        await this.endActiveTurn(session, "process_exit");
         session.status = code === 0 ? "stopped" : "error";
         if (!session.skipDb) {
           this.storage.agentSessions.updateStatus(session.id, session.status).catch((err) => {
             console.error(`[AgentSession] Failed to update status for ${session.id}:`, err);
           });
         }
-        if (code !== 0 && !spawnFailed && !session.producedOutput) {
-          this.pushEntry(session.id, {
-            type: "error",
-            message: this.buildStartupFailureMessage(session.agentType, stderrTail),
-            timestamp: Date.now()
-          }, true).catch((err) => {
-            console.error(`[AgentSession] Failed to push startup-failure entry for ${session.id}:`, err);
-          });
-        }
         this.broadcastPatch(session.id, ConversationPatch.updateStatus(session.status));
         this.eventBus?.emit({ type: "session:status", projectId: session.projectId, branch: session.branch, sessionId: session.id, status: session.status });
         this.broadcastRaw(session.id, { finished: true });
@@ -224227,6 +224494,7 @@ var AgentSessionManager = class {
       summaryText
     });
     await this.emitDerivedBranchActivity(session.projectId, session.branch);
+    await this.endActiveTurn(session, "completed");
     if (session.status !== "stopped") {
       session.status = "stopped";
       if (!session.skipDb) await this.storage.agentSessions.updateStatus(sessionId, "stopped");
@@ -224421,6 +224689,7 @@ var AgentSessionManager = class {
         }
         if (event.subtype === "error") {
           this.applyCompletionTimerAction(session, session.completion.errorResult());
+          await this.endActiveTurn(session, "failed");
           if (session.status !== "stopped") {
             session.status = "stopped";
             if (!session.skipDb) await this.storage.agentSessions.updateStatus(sessionId, "stopped");
@@ -224581,6 +224850,20 @@ ${details}`;
       await this.persistEntry(session, index, entry);
     }
   }
+  /**
+   * Close the open turn with a persisted turn_end stop-point entry.
+   * turn_end entries are constructed ONLY here and in repairInterruptedTurn
+   * (restore path). Wall clock only — see design doc for why the CLI's
+   * payload.duration_ms is not used. Rides the normal best-effort entry
+   * persistence on purpose (no strict path — design decision).
+   */
+  async endActiveTurn(session, outcome) {
+    if (session.turnOpenSince === null) return;
+    const endedAt = Date.now();
+    const durationMs = endedAt - session.turnOpenSince;
+    await this.pushEntry(session.id, { type: "turn_end", timestamp: endedAt, durationMs, outcome }, true);
+    session.turnOpenSince = null;
+  }
   /**
    * Send a user message to the agent
    */
@@ -224626,6 +224909,7 @@ ${details}`;
         `[AgentSession] sendUserMessage: wrote ${formatted.length}B to ${session.agentType} stdin (session=${sessionId})`
       );
       session.process.stdin.write(formatted);
+      if (session.turnOpenSince === null) session.turnOpenSince = Date.now();
       return true;
     } catch (error48) {
       console.error(`[AgentSession] Failed to send message:`, error48);
@@ -224744,6 +225028,7 @@ ${details}`;
         content: "Session stopped by user.",
         timestamp: Date.now()
       });
+      await this.endActiveTurn(session, "stopped");
       session.dormant = true;
       this.resetCompletion(session);
       session.status = "stopped";
@@ -224853,6 +225138,7 @@ ${details}`;
     session.store.currentAssistantIndex = null;
     session.buffer = "";
     session.dormant = false;
+    session.turnOpenSince = null;
     this.touchSession(session);
     const clearPatch = ConversationPatch.clearAll();
     this.broadcastPatch(sessionId, clearPatch);
@@ -225013,6 +225299,8 @@ ${details}`;
           break;
         case "system":
           break;
+        case "turn_end":
+          break;
       }
     }
     if (lines.length === 0) return null;
@@ -225055,6 +225343,7 @@ ${details}`;
       content: userMessage,
       timestamp: Date.now()
     }, true, userId);
+    session.turnOpenSince = Date.now();
     setTimeout(() => {
       const context2 = this.buildFullConversationContext(session.store.entries);
       if (context2) {
@@ -225105,6 +225394,34 @@ ${details}`;
     indexProvider.setIndex(maxIndex + 1);
     return store;
   }
+  /**
+   * Crash repair (restore path): if the previous process died mid-turn, the
+   * history has no closing turn_end — append one with outcome
+   * "server_restart" and no duration (the crash time is unknown; the UI
+   * shows "interrupted" instead of a fabricated number). Runs BEFORE
+   * rebuildStoreFromRows so the store is built from the repaired rows.
+   * The other constructor of turn_end entries is endActiveTurn (live paths).
+   */
+  async repairInterruptedTurn(sessionId, rows) {
+    let landingType = null;
+    for (let i = rows.length - 1; i >= 0; i--) {
+      try {
+        const msg = JSON.parse(rows[i].data);
+        if (msg.type === "system") continue;
+        landingType = msg.type;
+      } catch {
+        landingType = "unparsable";
+      }
+      break;
+    }
+    if (landingType === null || landingType === "turn_end") return rows;
+    const maxIndex = rows.reduce((m2, r) => Math.max(m2, r.entry_index), -1);
+    const repair = { type: "turn_end", timestamp: Date.now(), outcome: "server_restart" };
+    const data = JSON.stringify(repair);
+    await this.storage.agentSessions.upsertEntry(sessionId, maxIndex + 1, data);
+    console.log(`[AgentSession] Repaired interrupted turn for ${sessionId} (server_restart turn_end at ${maxIndex + 1})`);
+    return [...rows, { entry_index: maxIndex + 1, data }];
+  }
   /**
    * Restore sessions from database on startup.
    * Creates dormant RunningSession objects with process=null for sessions that have entries.
@@ -225114,8 +225431,11 @@ ${details}`;
     let restoredCount = 0;
     for (const dbSession of allSessions) {
       if (this.sessions.has(dbSession.id)) continue;
-      const entries = await this.storage.agentSessions.getEntries(dbSession.id);
+      let entries = await this.storage.agentSessions.getEntries(dbSession.id);
       if (entries.length === 0) continue;
+      if (dbSession.status === "running") {
+        entries = await this.repairInterruptedTurn(dbSession.id, entries);
+      }
       const store = this.rebuildStoreFromRows(entries, dbSession.id);
       const permissionMode = dbSession.permission_mode === "plan" ? "plan" : "edit";
       const runningSession = {
@@ -225136,7 +225456,8 @@ ${details}`;
         eventChain: Promise.resolve(),
         bgSpawnHintsThisTurn: 0,
         taskStartedThisTurn: 0,
-        lastActiveAt: Date.now()
+        lastActiveAt: Date.now(),
+        turnOpenSince: null
       };
       this.sessions.set(dbSession.id, runningSession);
       await this.storage.agentSessions.updateStatusPreservingTimestamp(dbSession.id, "stopped");
@@ -225154,17 +225475,38 @@ ${details}`;
    * message goes through wakeDormantSession, which replays the full copied
    * context to a fresh process, so a branch also works with a different
    * agent type than the source.
-   * Returns the new session id, or null when the source is unknown or has
-   * no persisted history to copy.
+   *
+   * `opts.upToEntryIndex`, when given, is an inclusive cutoff that must land
+   * on a `turn_end` row — every branch then ends with its own tail divider.
+   * With a cutoff the source's live process is never touched (no
+   * finalizeStreamingEntry), so a historical branch is safe even while the
+   * source is running. Without a cutoff (legacy full-copy callers) a running
+   * source is refused outright — copying mid-turn would leave the branch
+   * with a half-finished turn and no closing turn_end.
    */
   async branchSession(sourceSessionId, agentTypeOverride, opts = {}) {
     const source = this.sessions.get(sourceSessionId);
     const sourceRow = await this.storage.agentSessions.getById(sourceSessionId);
-    if (!source && !sourceRow) return null;
-    if (source?.skipDb) return null;
-    if (source) await this.finalizeStreamingEntry(source);
-    const entryRows = await this.storage.agentSessions.getEntries(sourceSessionId);
-    if (entryRows.length === 0) return null;
+    if (!source && !sourceRow) return { ok: false, reason: "not-found" };
+    if (source?.skipDb) return { ok: false, reason: "empty-history" };
+    if (opts.upToEntryIndex === void 0) {
+      if (source?.status === "running") return { ok: false, reason: "running-needs-cutoff" };
+      if (source) await this.finalizeStreamingEntry(source);
+    }
+    let entryRows = await this.storage.agentSessions.getEntries(sourceSessionId);
+    if (opts.upToEntryIndex !== void 0) {
+      const cut = entryRows.find((r) => r.entry_index === opts.upToEntryIndex);
+      let cutType = null;
+      if (cut) {
+        try {
+          cutType = JSON.parse(cut.data).type;
+        } catch {
+        }
+      }
+      if (cutType !== "turn_end") return { ok: false, reason: "invalid-cutoff" };
+      entryRows = entryRows.filter((r) => r.entry_index <= opts.upToEntryIndex);
+    }
+    if (entryRows.length === 0) return { ok: false, reason: "empty-history" };
     const projectId = source?.projectId ?? sourceRow.project_id;
     const branch = source?.branch ?? (sourceRow.branch || null);
     const permissionMode = source?.permissionMode ?? (sourceRow?.permission_mode === "plan" ? "plan" : "edit");
@@ -225216,12 +225558,13 @@ ${details}`;
       bgSpawnHintsThisTurn: 0,
       taskStartedThisTurn: 0,
       lastActiveAt: Date.now(),
+      turnOpenSince: null,
       crossRemoteMcp: opts.crossRemoteMcp
     };
     this.sessions.set(newId, branched);
     await this.emitDerivedBranchActivity(projectId, branch);
     console.log(`[AgentSession] branchSession: ${sourceSessionId} \u2192 ${newId} (entries=${entryRows.length}, agentType=${agentType})`);
-    return newId;
+    return { ok: true, sessionId: newId };
   }
   /**
    * Kill all active session processes and clear state for graceful shutdown
@@ -225907,12 +226250,12 @@ function extractLogText(logs, tailLines) {
   const lines = joined.split("\n");
   return stripAnsi(lines.slice(-tailLines).join("\n"));
 }
-function parseDbTimestamp(s3) {
+function parseDbTimestamp2(s3) {
   if (s3.includes("T") || s3.endsWith("Z")) return new Date(s3).getTime();
   return (/* @__PURE__ */ new Date(s3.replace(" ", "T") + "Z")).getTime();
 }
 function formatRelativeAge(timestamp, nowMs) {
-  const t = parseDbTimestamp(timestamp);
+  const t = parseDbTimestamp2(timestamp);
   if (Number.isNaN(t)) return "unknown";
   const sec = Math.max(0, Math.round((nowMs - t) / 1e3));
   if (sec < 60) return `${sec}s ago`;
@@ -227123,8 +227466,8 @@ var ChatSessionManager = class {
               };
             }
             const TURN_GRACE_MS = 1e3;
-            const startedThisTurn = turnStartedAt != null && parseDbTimestamp(lastRow.started_at) >= turnStartedAt - TURN_GRACE_MS;
-            const finishedThisTurn = turnStartedAt != null && lastRow.finished_at != null && parseDbTimestamp(lastRow.finished_at) >= turnStartedAt - TURN_GRACE_MS;
+            const startedThisTurn = turnStartedAt != null && parseDbTimestamp2(lastRow.started_at) >= turnStartedAt - TURN_GRACE_MS;
+            const finishedThisTurn = turnStartedAt != null && lastRow.finished_at != null && parseDbTimestamp2(lastRow.finished_at) >= turnStartedAt - TURN_GRACE_MS;
             return {
               name: executor.name,
               command: executor.command,
@@ -233149,14 +233492,21 @@ var routes11 = async (fastify2) => {
     if (!sourceRow || !await fastify2.storage.projects.getById(sourceRow.project_id, userId)) {
       return { ok: false, code: 404, error: "Session not found" };
     }
-    const newSessionId = await fastify2.agentSessionManager.branchSession(
+    const result = await fastify2.agentSessionManager.branchSession(
       sourceSessionId,
       opts.agentType,
-      { sessionId: opts.sessionId, crossRemoteMcp: opts.crossRemoteMcp }
+      { sessionId: opts.sessionId, crossRemoteMcp: opts.crossRemoteMcp, upToEntryIndex: opts.upToEntryIndex }
     );
-    if (!newSessionId) {
+    if (!result.ok) {
+      if (result.reason === "invalid-cutoff") {
+        return { ok: false, code: 400, error: "upToEntryIndex must reference a turn_end stop point" };
+      }
+      if (result.reason === "running-needs-cutoff") {
+        return { ok: false, code: 409, error: "Session is running; branching requires a stop-point cutoff" };
+      }
       return { ok: false, code: 404, error: "Session not found or has no history to branch" };
     }
+    const newSessionId = result.sessionId;
     const session = fastify2.agentSessionManager.getSession(newSessionId);
     const messages = fastify2.agentSessionManager.getMessages(newSessionId);
     const dbRow = await fastify2.storage.agentSessions.getById(newSessionId);
@@ -233906,7 +234256,10 @@ var routes11 = async (fastify2) => {
   fastify2.post(
     "/api/agent-sessions/:sessionId/branch",
     async (req, reply) => {
-      const { agentType } = req.body || {};
+      const { agentType, upToEntryIndex } = req.body || {};
+      if (upToEntryIndex !== void 0 && (!Number.isInteger(upToEntryIndex) || upToEntryIndex < 0)) {
+        return reply.code(400).send({ error: "upToEntryIndex must be a non-negative integer" });
+      }
       const userId = requireAuth(req, reply);
       if (userId === null) return;
       if (req.params.sessionId.startsWith("remote-")) {
@@ -233927,7 +234280,7 @@ var routes11 = async (fastify2) => {
           remoteInfo.remoteApiKey,
           "POST",
           `/api/path/agent-sessions/${remoteInfo.remoteSessionId}/branch`,
-          { agentType, sessionId: newRemoteSessionId, crossRemoteMcp: crossRemoteMcp2 }
+          { agentType, sessionId: newRemoteSessionId, crossRemoteMcp: crossRemoteMcp2, upToEntryIndex }
         );
         if (!result.ok) {
           return reply.code(proxyStatus(result)).send(result.data);
@@ -233936,6 +234289,12 @@ var routes11 = async (fastify2) => {
         if (remoteData.session.id !== newRemoteSessionId) {
           return reply.code(409).send({ error: "Remote returned an unexpected session id; upgrade the remote" });
         }
+        if (upToEntryIndex !== void 0 && remoteData.messages.length > upToEntryIndex + 1) {
+          console.error(
+            `[Branch] Remote ${remoteInfo.remoteServerId} ignored branch cutoff (${remoteData.messages.length} messages > cutoff ${upToEntryIndex}) \u2014 version drift, upgrade the remote`
+          );
+          return reply.code(409).send({ error: "Remote ignored branch cutoff; upgrade the remote" });
+        }
         fastify2.remoteSessionMap.set(localSessionId, {
           remoteServerId: remoteInfo.remoteServerId,
           remoteUrl: remoteInfo.remoteUrl,
@@ -233979,7 +234338,8 @@ var routes11 = async (fastify2) => {
       const branched = await performLocalBranch(req.params.sessionId, userId, {
         agentType,
         sessionId: preSessionId,
-        crossRemoteMcp
+        crossRemoteMcp,
+        upToEntryIndex
       });
       if (!branched.ok) {
         return reply.code(branched.code).send({ error: branched.error });
@@ -233988,13 +234348,17 @@ var routes11 = async (fastify2) => {
     }
   );
   fastify2.post("/api/path/agent-sessions/:sessionId/branch", async (req, reply) => {
-    const { agentType, sessionId, crossRemoteMcp } = req.body || {};
+    const { agentType, sessionId, crossRemoteMcp, upToEntryIndex } = req.body || {};
+    if (upToEntryIndex !== void 0 && (!Number.isInteger(upToEntryIndex) || upToEntryIndex < 0)) {
+      return reply.code(400).send({ error: "upToEntryIndex must be a non-negative integer" });
+    }
     const userId = requireAuth(req, reply);
     if (userId === null) return;
     const branched = await performLocalBranch(req.params.sessionId, userId, {
       agentType,
       sessionId,
-      crossRemoteMcp
+      crossRemoteMcp,
+      upToEntryIndex
     });
     if (!branched.ok) {
       return reply.code(branched.code).send({ error: branched.error });
@@ -234180,6 +234544,13 @@ var routes11 = async (fastify2) => {
           remoteInfo.branch ?? null,
           normalizedTitle
         );
+        if (normalizedTitle) {
+          try {
+            await fastify2.storage.searchCache.updateCachedSessionTitle(req.params.sessionId, normalizedTitle);
+          } catch (err) {
+            console.error("[API] searchCache.updateCachedSessionTitle failed:", err);
+          }
+        }
       }
       return reply.code(proxyStatus(result)).send(result.data);
     }
@@ -234309,6 +234680,77 @@ var branch_activity_routes_default = (0, import_fastify_plugin13.default)(routes
 
 // src/routes/merge-status-routes.ts
 var import_fastify_plugin14 = __toESM(require_plugin2(), 1);
+function resolveTargets(comparisons, storedTargets) {
+  const sources = [];
+  const effective = comparisons.map((comparison) => {
+    if (comparison.target !== void 0) {
+      sources.push("request");
+      return comparison;
+    }
+    const storedTarget = storedTargets.get(comparison.branch);
+    if (storedTarget !== void 0) {
+      sources.push("stored");
+      return { branch: comparison.branch, target: storedTarget };
+    }
+    sources.push("default");
+    return comparison;
+  });
+  return { comparisons: effective, sources };
+}
+function annotateEntries(entries, comparisons, sources) {
+  return entries.map((entry, index) => ({
+    ...entry,
+    targetSource: sources[index],
+    requestedTarget: comparisons[index]?.target ?? entry.target
+  }));
+}
+var MERGE_PAIR_ERRORS = /* @__PURE__ */ new Set([
+  "target-not-found",
+  "branch-not-found",
+  "no-default-branch"
+]);
+var MERGE_STATUS_VALUES = /* @__PURE__ */ new Set([
+  "merged",
+  "partial",
+  "unmerged",
+  "no-unique-commits"
+]);
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isRemoteMergeStatusEntry(value, comparison) {
+  if (!isRecord(value) || value.branch !== comparison.branch) return false;
+  if (value.target !== null && typeof value.target !== "string") return false;
+  if (value.error !== void 0) {
+    if (!MERGE_PAIR_ERRORS.has(value.error)) return false;
+    if (value.status !== void 0 || value.unmergedCount !== void 0 || value.dirty !== void 0) {
+      return false;
+    }
+    if (value.error === "target-not-found") {
+      return comparison.target !== void 0 && value.target === null;
+    }
+    if (value.error === "no-default-branch") {
+      return comparison.target === void 0 && value.target === null;
+    }
+    return typeof value.target === "string" && (comparison.target === void 0 || value.target === comparison.target);
+  }
+  return typeof value.target === "string" && (comparison.target === void 0 || value.target === comparison.target) && MERGE_STATUS_VALUES.has(value.status) && Number.isInteger(value.unmergedCount) && value.unmergedCount >= 0 && typeof value.dirty === "boolean";
+}
+function parseRemoteEntries(data, comparisons) {
+  if (!isRecord(data) || !Array.isArray(data.entries)) return null;
+  if (data.entries.length !== comparisons.length) return null;
+  if (!data.entries.every((entry, index) => isRemoteMergeStatusEntry(entry, comparisons[index]))) {
+    return null;
+  }
+  const entries = data.entries;
+  const implicitEntries = entries.filter((_entry, index) => comparisons[index].target === void 0);
+  const hasNoDefault = implicitEntries.some((entry) => entry.error === "no-default-branch");
+  if (hasNoDefault) {
+    return implicitEntries.every((entry) => entry.error === "no-default-branch") ? entries : null;
+  }
+  const resolvedDefault = implicitEntries[0]?.target;
+  return implicitEntries.every((entry) => entry.target === resolvedDefault) ? entries : null;
+}
 function legacyRemoteLabel(remoteUrl) {
   try {
     return new URL(remoteUrl).hostname;
@@ -234340,6 +234782,10 @@ async function getRemoteConfig4(fastify2, project) {
   return null;
 }
 var MAX_COMPARISONS = 50;
+var MAX_NAME_LENGTH = 256;
+function isValidName(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= MAX_NAME_LENGTH;
+}
 function parseComparisons(body) {
   if (!body || typeof body !== "object") return null;
   const comparisons = body.comparisons;
@@ -234395,6 +234841,11 @@ var routes13 = async (fastify2) => {
       if (!comparisons) {
         return reply.code(400).send({ error: "Invalid comparisons" });
       }
+      const storedTargets = await fastify2.storage.mergeTargets.getForBranches(
+        project.id,
+        comparisons.map(({ branch }) => branch)
+      );
+      const resolved = resolveTargets(comparisons, storedTargets);
       if (!project.path) {
         const remoteConfig = await getRemoteConfig4(fastify2, project);
         if (!remoteConfig) {
@@ -234406,28 +234857,83 @@ var routes13 = async (fastify2) => {
           remoteConfig.apiKey,
           "POST",
           "/api/path/branches/merge-status",
-          { path: remoteConfig.remotePath, comparisons },
+          { path: remoteConfig.remotePath, comparisons: resolved.comparisons },
           { reverseConnectManager: fastify2.reverseConnectManager }
         );
         if (!result.ok) {
           return reply.code(proxyStatus(result)).send(result.data);
         }
-        const data = result.data;
+        const entries = parseRemoteEntries(result.data, resolved.comparisons);
+        if (!entries) {
+          return reply.code(502).send({ error: "Remote merge-status response invalid" });
+        }
         return reply.code(200).send({
           repository: {
             kind: "remote",
             remoteServerId: remoteConfig.serverId,
             label: remoteConfig.serverName
           },
-          entries: data.entries ?? []
+          entries: annotateEntries(
+            entries,
+            resolved.comparisons,
+            resolved.sources
+          )
         });
       }
-      return sendComputed(
-        reply,
-        project.path,
-        comparisons,
-        { kind: "local", label: "Local" }
-      );
+      try {
+        const entries = computeMergeStatusPairs(project.path, resolved.comparisons);
+        return reply.code(200).send({
+          repository: { kind: "local", label: "Local" },
+          entries: annotateEntries(entries, resolved.comparisons, resolved.sources)
+        });
+      } catch (error48) {
+        const statusCode = error48.statusCode ?? 500;
+        const message = error48 instanceof Error ? error48.message : "Failed to compute merge status";
+        return reply.code(statusCode).send({ error: message });
+      }
+    }
+  );
+  fastify2.put(
+    "/api/projects/:id/branches/merge-target",
+    async (req, reply) => {
+      const userId = requireAuth(req, reply);
+      if (userId === null) return;
+      const project = await fastify2.storage.projects.getById(req.params.id, userId);
+      if (!project) {
+        return reply.code(404).send({ error: "Project not found" });
+      }
+      if (!req.body || typeof req.body !== "object") {
+        return reply.code(400).send({ error: "Invalid merge target" });
+      }
+      const body = req.body;
+      const { branch, target, ifAbsent } = body;
+      if (!isValidName(branch) || target !== null && !isValidName(target) || ifAbsent !== void 0 && typeof ifAbsent !== "boolean" || ifAbsent === true && target === null) {
+        return reply.code(400).send({ error: "Invalid merge target" });
+      }
+      let changed;
+      let storedTarget;
+      if (target === null) {
+        changed = await fastify2.storage.mergeTargets.delete(project.id, branch);
+        storedTarget = null;
+      } else if (ifAbsent === true) {
+        changed = await fastify2.storage.mergeTargets.insertIfAbsent(project.id, branch, target);
+        if (changed) {
+          storedTarget = target;
+        } else {
+          storedTarget = (await fastify2.storage.mergeTargets.getForBranches(project.id, [branch])).get(branch) ?? null;
+        }
+      } else {
+        changed = await fastify2.storage.mergeTargets.upsert(project.id, branch, target);
+        storedTarget = target;
+      }
+      if (changed) {
+        fastify2.eventBus.emit({
+          type: "merge-target:updated",
+          projectId: project.id,
+          branch
+        });
+      }
+      return reply.code(200).send({ branch, target: storedTarget });
     }
   );
 };
@@ -234873,7 +235379,7 @@ var SCROLLBACK_MAX = 1e5;
 var FONT_SIZE_MIN = 8;
 var FONT_SIZE_MAX = 32;
 var DEFAULT_CONVERSATION_SETTINGS = {
-  agentFontSize: 15,
+  agentFontSize: 16,
   chatFontSize: 15,
   filesTreeFontSize: 14,
   filesContentFontSize: 14
@@ -237639,6 +238145,244 @@ var routes28 = async (fastify2) => {
 };
 var schedule_routes_default = (0, import_fastify_plugin29.default)(routes28, { name: "schedule-routes" });
 
+// src/search/catalog.ts
+var parseDbTimestamp3 = (ts) => {
+  if (!ts) return null;
+  const ms = Date.parse(ts.replace(" ", "T") + "Z");
+  return Number.isNaN(ms) ? null : ms;
+};
+async function buildSearchCatalog(deps, projectId, projectPath) {
+  pruneWorktrees(projectPath);
+  const workspaces = getWorktreeBranches(projectPath);
+  const sessions = await deps.storage.agentSessions.getByProjectId(projectId);
+  const counts = new Map(
+    (await deps.storage.agentSessions.countEntries()).map((r) => [r.session_id, r.cnt])
+  );
+  return {
+    snapshotAt: Date.now(),
+    workspaces,
+    sessions: sessions.map((s3) => ({ s: s3, entryCount: counts.get(s3.id) ?? 0 })).filter(({ s: s3, entryCount }) => shouldShowBranchSessionInList({
+      entryCount,
+      processAlive: deps.getProcessAlive?.(s3.id) ?? false
+    })).map(({ s: s3, entryCount }) => ({
+      id: s3.id,
+      branch: s3.branch === "" ? null : s3.branch,
+      title: s3.title ?? null,
+      lastActiveAt: s3.last_user_message_at ?? parseDbTimestamp3(s3.updated_at),
+      favoritedAt: s3.favorited_at ?? null,
+      entryCount
+    }))
+  };
+}
+
+// src/search/refresh.ts
+var DEFAULT_TTL_MS = 3e4;
+var DEFAULT_DEADLINE_MS = 5e3;
+var PER_WORKER_CONCURRENCY = 3;
+var LOCAL_CONCURRENCY = 4;
+async function listSearchTargets(storage, userId) {
+  const projects = await storage.projects.getAll(userId);
+  const targets = [];
+  for (const p2 of projects) {
+    if (p2.path) targets.push({ projectId: p2.id, targetId: "local", projectPath: p2.path });
+    const remotes = await storage.projectRemotes.getByProject(p2.id);
+    for (const r of remotes) {
+      targets.push({
+        projectId: p2.id,
+        targetId: r.remote_server_id,
+        remote: {
+          serverId: r.remote_server_id,
+          url: r.server_url ?? "",
+          apiKey: r.server_api_key ?? "",
+          remotePath: r.remote_path
+        }
+      });
+    }
+  }
+  return targets;
+}
+function computeCacheState(states, targets, now2, ttlMs = DEFAULT_TTL_MS) {
+  if (targets.length === 0) return "fresh";
+  const stateByKey = new Map(states.map((s3) => [`${s3.project_id}:${s3.target_id}`, s3]));
+  const matched = targets.map((t) => stateByKey.get(`${t.projectId}:${t.targetId}`));
+  if (matched.some((s3) => s3?.last_success_at == null)) return "cold";
+  return matched.every((s3) => now2 - (s3.last_success_at ?? 0) <= ttlMs) ? "fresh" : "stale";
+}
+async function runWithConcurrency(tasks, limit) {
+  const queue = [...tasks];
+  const workers = Array.from({ length: Math.max(1, Math.min(limit, queue.length)) }, async () => {
+    for (let task = queue.shift(); task; task = queue.shift()) {
+      await task();
+    }
+  });
+  await Promise.all(workers);
+}
+function createSearchRefresher(deps) {
+  const ttlMs = deps.ttlMs ?? DEFAULT_TTL_MS;
+  const deadlineMs = deps.deadlineMs ?? DEFAULT_DEADLINE_MS;
+  const now2 = deps.now ?? Date.now;
+  const inflight = /* @__PURE__ */ new Map();
+  function refreshTarget(t) {
+    const key = `${t.projectId}:${t.targetId}`;
+    const existing = inflight.get(key);
+    if (existing) return existing;
+    const run2 = (async () => {
+      try {
+        const snapshot = t.targetId === "local" ? await deps.buildLocalCatalog(t.projectId, t.projectPath ?? "") : await deps.fetchRemoteCatalog(t);
+        await deps.storage.searchCache.applyCatalogSnapshot(t.projectId, t.targetId, snapshot);
+      } catch (err) {
+        await deps.storage.searchCache.recordSyncFailure(
+          t.projectId,
+          t.targetId,
+          err instanceof Error ? err.message : String(err)
+        ).catch(() => {
+        });
+      }
+    })();
+    inflight.set(key, run2);
+    void run2.finally(() => inflight.delete(key));
+    return run2;
+  }
+  async function refreshAll(userId) {
+    const targets = await listSearchTargets(deps.storage, userId);
+    const states = await deps.storage.searchCache.getSyncStates([...new Set(targets.map((t) => t.projectId))]);
+    const stateByKey = new Map(states.map((s3) => [`${s3.project_id}:${s3.target_id}`, s3]));
+    const due = targets.filter((t) => {
+      const s3 = stateByKey.get(`${t.projectId}:${t.targetId}`);
+      return !s3?.last_success_at || now2() - s3.last_success_at > ttlMs;
+    });
+    const byWorker = /* @__PURE__ */ new Map();
+    for (const t of due) {
+      const k2 = t.targetId;
+      byWorker.set(k2, [...byWorker.get(k2) ?? [], t]);
+    }
+    const lanes = [...byWorker.entries()].map(
+      ([workerId, ts]) => runWithConcurrency(
+        ts.map((t) => () => refreshTarget(t)),
+        workerId === "local" ? LOCAL_CONCURRENCY : PER_WORKER_CONCURRENCY
+      )
+    );
+    const all = Promise.all(lanes).then(() => void 0);
+    await Promise.race([
+      all,
+      new Promise((resolve3) => {
+        const timer = setTimeout(resolve3, deadlineMs);
+        timer.unref?.();
+      })
+    ]);
+  }
+  return { refreshAll };
+}
+
+// src/routes/search-routes.ts
+var searchRoutes = async (fastify2) => {
+  fastify2.get(
+    "/api/path/search-catalog",
+    async (req, reply) => {
+      const projectPath = req.query.path;
+      if (!projectPath) {
+        return reply.code(400).send({ error: "path is required" });
+      }
+      const project = await fastify2.storage.projects.getByPath(projectPath);
+      if (!project) {
+        return reply.code(200).send({ snapshotAt: Date.now(), workspaces: [], sessions: [] });
+      }
+      try {
+        const catalog = await buildSearchCatalog(
+          {
+            storage: fastify2.storage,
+            getProcessAlive: (id) => fastify2.agentSessionManager.getSessionProcessAlive(id)
+          },
+          project.id,
+          projectPath
+        );
+        return reply.code(200).send(catalog);
+      } catch (error48) {
+        return reply.code(500).send({ error: String(error48) });
+      }
+    }
+  );
+  const refresher = createSearchRefresher({
+    storage: fastify2.storage,
+    buildLocalCatalog: (projectId, projectPath) => buildSearchCatalog(
+      {
+        storage: fastify2.storage,
+        getProcessAlive: (id) => fastify2.agentSessionManager.getSessionProcessAlive(id)
+      },
+      projectId,
+      projectPath
+    ),
+    fetchRemoteCatalog: async (target) => {
+      const r = target.remote;
+      if (!r) throw new Error("remote target without remote config");
+      const params = new URLSearchParams({ path: r.remotePath });
+      const result = await proxyToRemoteAuto(
+        r.serverId,
+        r.url,
+        r.apiKey,
+        "GET",
+        `/api/path/search-catalog?${params.toString()}`,
+        void 0,
+        { reverseConnectManager: fastify2.reverseConnectManager, timeoutMs: 2e3 }
+      );
+      if (!result.ok) {
+        throw new Error(`catalog fetch failed: ${result.status} ${result.errorCode ?? ""}`);
+      }
+      const data = result.data;
+      const sessions = await Promise.all(data.sessions.map(async (s3) => {
+        const localSessionId = `remote-${target.targetId}-${target.projectId}-${s3.id}`;
+        const mapBranch = s3.branch ?? "";
+        if (!fastify2.remoteSessionMap.has(localSessionId)) {
+          fastify2.remoteSessionMap.set(localSessionId, {
+            remoteServerId: target.targetId,
+            remoteUrl: r.url,
+            remoteApiKey: r.apiKey,
+            remoteSessionId: s3.id,
+            branch: mapBranch
+          });
+        }
+        await fastify2.storage.remoteSessionMappings.upsert(
+          localSessionId,
+          target.projectId,
+          target.targetId,
+          s3.id,
+          mapBranch
+        );
+        return { ...s3, id: localSessionId };
+      }));
+      return { workspaces: data.workspaces, sessions };
+    }
+  });
+  async function currentCacheState(userId) {
+    const targets = await listSearchTargets(fastify2.storage, userId);
+    const states = await fastify2.storage.searchCache.getSyncStates(
+      [...new Set(targets.map((t) => t.projectId))]
+    );
+    return computeCacheState(states, targets, Date.now());
+  }
+  fastify2.get(
+    "/api/search",
+    async (req, reply) => {
+      const userId = requireAuth(req, reply);
+      if (userId === null) return;
+      const query = (req.query.q ?? "").slice(0, 256);
+      const parsed = parseInt(req.query.limitPerGroup ?? "10", 10);
+      const limitPerGroup = Math.min(Math.max(Number.isNaN(parsed) ? 10 : parsed, 1), 50);
+      const results = await fastify2.storage.searchCache.search({ userId, query, limitPerGroup });
+      const cacheState = await currentCacheState(userId);
+      return reply.code(200).send({ ...results, cacheState });
+    }
+  );
+  fastify2.post("/api/search/refresh", async (req, reply) => {
+    const userId = requireAuth(req, reply);
+    if (userId === null) return;
+    await refresher.refreshAll(userId);
+    const cacheState = await currentCacheState(userId);
+    return reply.code(200).send({ ok: true, cacheState });
+  });
+};
+var search_routes_default = searchRoutes;
+
 // ../../node_modules/.pnpm/@clerk+fastify@3.1.2_fastify@5.7.2_react-dom@19.2.3_react@19.2.3__react@19.2.3/node_modules/@clerk/fastify/dist/chunk-RY4T2JMQ.mjs
 import { Readable as Readable3 } from "stream";
 var fastifyRequestToRequest = (req) => {
@@ -238896,6 +239640,7 @@ var createServer = async (opts) => {
   server.register(remote_routes_default);
   server.register(remote_server_routes_default);
   server.register(project_remote_routes_default);
+  server.register(search_routes_default);
   server.register(executor_group_routes_default);
   server.register(executor_routes_default);
   server.register(schedule_routes_default);

package/package.json

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