chat-logbook 0.13.0 → 0.14.0

package/api/dist/index.js

@@ -5,9 +5,9 @@ var __export = (target, all) => {
 };
 
 // src/index.ts
-import fs6 from "fs";
+import fs8 from "fs";
 import os from "os";
-import path4 from "path";
+import path7 from "path";
 import { exec } from "child_process";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
@@ -304,13 +304,13 @@ function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromi
     }
   }
 }
-function writeFromReadableStream(stream, writable) {
-  if (stream.locked) {
+function writeFromReadableStream(stream2, writable) {
+  if (stream2.locked) {
     throw new TypeError("ReadableStream is locked.");
   } else if (writable.destroyed) {
     return;
   }
-  return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
+  return writeFromReadableStreamDefaultReader(stream2.getReader(), writable);
 }
 var buildOutgoingHttpHeaders = (headers) => {
   const res = {};
@@ -705,26 +705,26 @@ var handleParsingNestedValues = (form, key, value) => {
 };
 
 // ../node_modules/.pnpm/hono@4.12.9/node_modules/hono/dist/utils/url.js
-var splitPath = (path5) => {
-  const paths = path5.split("/");
+var splitPath = (path8) => {
+  const paths = path8.split("/");
   if (paths[0] === "") {
     paths.shift();
   }
   return paths;
 };
 var splitRoutingPath = (routePath) => {
-  const { groups, path: path5 } = extractGroupsFromPath(routePath);
-  const paths = splitPath(path5);
+  const { groups, path: path8 } = extractGroupsFromPath(routePath);
+  const paths = splitPath(path8);
   return replaceGroupMarks(paths, groups);
 };
-var extractGroupsFromPath = (path5) => {
+var extractGroupsFromPath = (path8) => {
   const groups = [];
-  path5 = path5.replace(/\{[^}]+\}/g, (match2, index2) => {
+  path8 = path8.replace(/\{[^}]+\}/g, (match2, index2) => {
     const mark = `@${index2}`;
     groups.push([mark, match2]);
     return mark;
   });
-  return { groups, path: path5 };
+  return { groups, path: path8 };
 };
 var replaceGroupMarks = (paths, groups) => {
   for (let i = groups.length - 1; i >= 0; i--) {
@@ -781,8 +781,8 @@ var getPath = (request) => {
       const queryIndex = url.indexOf("?", i);
       const hashIndex = url.indexOf("#", i);
       const end = queryIndex === -1 ? hashIndex === -1 ? void 0 : hashIndex : hashIndex === -1 ? queryIndex : Math.min(queryIndex, hashIndex);
-      const path5 = url.slice(start, end);
-      return tryDecodeURI(path5.includes("%25") ? path5.replace(/%25/g, "%2525") : path5);
+      const path8 = url.slice(start, end);
+      return tryDecodeURI(path8.includes("%25") ? path8.replace(/%25/g, "%2525") : path8);
     } else if (charCode === 63 || charCode === 35) {
       break;
     }
@@ -799,11 +799,11 @@ var mergePath = (base, sub, ...rest) => {
   }
   return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
 };
-var checkOptionalParameter = (path5) => {
-  if (path5.charCodeAt(path5.length - 1) !== 63 || !path5.includes(":")) {
+var checkOptionalParameter = (path8) => {
+  if (path8.charCodeAt(path8.length - 1) !== 63 || !path8.includes(":")) {
     return null;
   }
-  const segments = path5.split("/");
+  const segments = path8.split("/");
   const results = [];
   let basePath = "";
   segments.forEach((segment) => {
@@ -944,9 +944,9 @@ var HonoRequest = class {
    */
   path;
   bodyCache = {};
-  constructor(request, path5 = "/", matchResult = [[]]) {
+  constructor(request, path8 = "/", matchResult = [[]]) {
     this.raw = request;
-    this.path = path5;
+    this.path = path8;
     this.#matchResult = matchResult;
     this.#validatedData = {};
   }
@@ -1683,8 +1683,8 @@ var Hono = class _Hono {
         return this;
       };
     });
-    this.on = (method, path5, ...handlers) => {
-      for (const p of [path5].flat()) {
+    this.on = (method, path8, ...handlers) => {
+      for (const p of [path8].flat()) {
         this.#path = p;
         for (const m of [method].flat()) {
           handlers.map((handler) => {
@@ -1741,8 +1741,8 @@ var Hono = class _Hono {
    * app.route("/api", app2) // GET /api/user
    * ```
    */
-  route(path5, app2) {
-    const subApp = this.basePath(path5);
+  route(path8, app2) {
+    const subApp = this.basePath(path8);
     app2.routes.map((r) => {
       let handler;
       if (app2.errorHandler === errorHandler) {
@@ -1768,9 +1768,9 @@ var Hono = class _Hono {
    * const api = new Hono().basePath('/api')
    * ```
    */
-  basePath(path5) {
+  basePath(path8) {
     const subApp = this.#clone();
-    subApp._basePath = mergePath(this._basePath, path5);
+    subApp._basePath = mergePath(this._basePath, path8);
     return subApp;
   }
   /**
@@ -1844,7 +1844,7 @@ var Hono = class _Hono {
    * })
    * ```
    */
-  mount(path5, applicationHandler, options) {
+  mount(path8, applicationHandler, options) {
     let replaceRequest;
     let optionHandler;
     if (options) {
@@ -1871,7 +1871,7 @@ var Hono = class _Hono {
       return [c.env, executionContext];
     };
     replaceRequest ||= (() => {
-      const mergedPath = mergePath(this._basePath, path5);
+      const mergedPath = mergePath(this._basePath, path8);
       const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
       return (request) => {
         const url = new URL(request.url);
@@ -1886,14 +1886,14 @@ var Hono = class _Hono {
       }
       await next();
     };
-    this.#addRoute(METHOD_NAME_ALL, mergePath(path5, "*"), handler);
+    this.#addRoute(METHOD_NAME_ALL, mergePath(path8, "*"), handler);
     return this;
   }
-  #addRoute(method, path5, handler) {
+  #addRoute(method, path8, handler) {
     method = method.toUpperCase();
-    path5 = mergePath(this._basePath, path5);
-    const r = { basePath: this._basePath, path: path5, method, handler };
-    this.router.add(method, path5, [handler, r]);
+    path8 = mergePath(this._basePath, path8);
+    const r = { basePath: this._basePath, path: path8, method, handler };
+    this.router.add(method, path8, [handler, r]);
     this.routes.push(r);
   }
   #handleError(err, c) {
@@ -1906,10 +1906,10 @@ var Hono = class _Hono {
     if (method === "HEAD") {
       return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
     }
-    const path5 = this.getPath(request, { env });
-    const matchResult = this.router.match(method, path5);
+    const path8 = this.getPath(request, { env });
+    const matchResult = this.router.match(method, path8);
     const c = new Context(request, {
-      path: path5,
+      path: path8,
       matchResult,
       env,
       executionCtx,
@@ -2009,7 +2009,7 @@ var Hono = class _Hono {
 
 // ../node_modules/.pnpm/hono@4.12.9/node_modules/hono/dist/router/reg-exp-router/matcher.js
 var emptyParam = [];
-function match(method, path5) {
+function match(method, path8) {
   const matchers = this.buildAllMatchers();
   const match2 = ((method2, path22) => {
     const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
@@ -2025,7 +2025,7 @@ function match(method, path5) {
     return [matcher[1][index2], match3];
   });
   this.match = match2;
-  return match2(method, path5);
+  return match2(method, path8);
 }
 
 // ../node_modules/.pnpm/hono@4.12.9/node_modules/hono/dist/router/reg-exp-router/node.js
@@ -2140,12 +2140,12 @@ var Node = class _Node {
 var Trie = class {
   #context = { varIndex: 0 };
   #root = new Node();
-  insert(path5, index2, pathErrorCheckOnly) {
+  insert(path8, index2, pathErrorCheckOnly) {
     const paramAssoc = [];
     const groups = [];
     for (let i = 0; ; ) {
       let replaced = false;
-      path5 = path5.replace(/\{[^}]+\}/g, (m) => {
+      path8 = path8.replace(/\{[^}]+\}/g, (m) => {
         const mark = `@\\${i}`;
         groups[i] = [mark, m];
         i++;
@@ -2156,7 +2156,7 @@ var Trie = class {
         break;
       }
     }
-    const tokens = path5.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+    const tokens = path8.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
     for (let i = groups.length - 1; i >= 0; i--) {
       const [mark] = groups[i];
       for (let j = tokens.length - 1; j >= 0; j--) {
@@ -2195,9 +2195,9 @@ var Trie = class {
 // ../node_modules/.pnpm/hono@4.12.9/node_modules/hono/dist/router/reg-exp-router/router.js
 var nullMatcher = [/^$/, [], /* @__PURE__ */ Object.create(null)];
 var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
-function buildWildcardRegExp(path5) {
-  return wildcardRegExpCache[path5] ??= new RegExp(
-    path5 === "*" ? "" : `^${path5.replace(
+function buildWildcardRegExp(path8) {
+  return wildcardRegExpCache[path8] ??= new RegExp(
+    path8 === "*" ? "" : `^${path8.replace(
       /\/\*$|([.\\+*[^\]$()])/g,
       (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)"
     )}$`
@@ -2219,17 +2219,17 @@ function buildMatcherFromPreprocessedRoutes(routes) {
   );
   const staticMap = /* @__PURE__ */ Object.create(null);
   for (let i = 0, j = -1, len = routesWithStaticPathFlag.length; i < len; i++) {
-    const [pathErrorCheckOnly, path5, handlers] = routesWithStaticPathFlag[i];
+    const [pathErrorCheckOnly, path8, handlers] = routesWithStaticPathFlag[i];
     if (pathErrorCheckOnly) {
-      staticMap[path5] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
+      staticMap[path8] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
     } else {
       j++;
     }
     let paramAssoc;
     try {
-      paramAssoc = trie.insert(path5, j, pathErrorCheckOnly);
+      paramAssoc = trie.insert(path8, j, pathErrorCheckOnly);
     } catch (e) {
-      throw e === PATH_ERROR ? new UnsupportedPathError(path5) : e;
+      throw e === PATH_ERROR ? new UnsupportedPathError(path8) : e;
     }
     if (pathErrorCheckOnly) {
       continue;
@@ -2263,12 +2263,12 @@ function buildMatcherFromPreprocessedRoutes(routes) {
   }
   return [regexp, handlerMap, staticMap];
 }
-function findMiddleware(middleware, path5) {
+function findMiddleware(middleware, path8) {
   if (!middleware) {
     return void 0;
   }
   for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
-    if (buildWildcardRegExp(k).test(path5)) {
+    if (buildWildcardRegExp(k).test(path8)) {
       return [...middleware[k]];
     }
   }
@@ -2282,7 +2282,7 @@ var RegExpRouter = class {
     this.#middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
     this.#routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
   }
-  add(method, path5, handler) {
+  add(method, path8, handler) {
     const middleware = this.#middleware;
     const routes = this.#routes;
     if (!middleware || !routes) {
@@ -2297,18 +2297,18 @@ var RegExpRouter = class {
         });
       });
     }
-    if (path5 === "/*") {
-      path5 = "*";
+    if (path8 === "/*") {
+      path8 = "*";
     }
-    const paramCount = (path5.match(/\/:/g) || []).length;
-    if (/\*$/.test(path5)) {
-      const re = buildWildcardRegExp(path5);
+    const paramCount = (path8.match(/\/:/g) || []).length;
+    if (/\*$/.test(path8)) {
+      const re = buildWildcardRegExp(path8);
       if (method === METHOD_NAME_ALL) {
         Object.keys(middleware).forEach((m) => {
-          middleware[m][path5] ||= findMiddleware(middleware[m], path5) || findMiddleware(middleware[METHOD_NAME_ALL], path5) || [];
+          middleware[m][path8] ||= findMiddleware(middleware[m], path8) || findMiddleware(middleware[METHOD_NAME_ALL], path8) || [];
         });
       } else {
-        middleware[method][path5] ||= findMiddleware(middleware[method], path5) || findMiddleware(middleware[METHOD_NAME_ALL], path5) || [];
+        middleware[method][path8] ||= findMiddleware(middleware[method], path8) || findMiddleware(middleware[METHOD_NAME_ALL], path8) || [];
       }
       Object.keys(middleware).forEach((m) => {
         if (method === METHOD_NAME_ALL || method === m) {
@@ -2326,7 +2326,7 @@ var RegExpRouter = class {
       });
       return;
     }
-    const paths = checkOptionalParameter(path5) || [path5];
+    const paths = checkOptionalParameter(path8) || [path8];
     for (let i = 0, len = paths.length; i < len; i++) {
       const path22 = paths[i];
       Object.keys(routes).forEach((m) => {
@@ -2353,13 +2353,13 @@ var RegExpRouter = class {
     const routes = [];
     let hasOwnRoute = method === METHOD_NAME_ALL;
     [this.#middleware, this.#routes].forEach((r) => {
-      const ownRoute = r[method] ? Object.keys(r[method]).map((path5) => [path5, r[method][path5]]) : [];
+      const ownRoute = r[method] ? Object.keys(r[method]).map((path8) => [path8, r[method][path8]]) : [];
       if (ownRoute.length !== 0) {
         hasOwnRoute ||= true;
         routes.push(...ownRoute);
       } else if (method !== METHOD_NAME_ALL) {
         routes.push(
-          ...Object.keys(r[METHOD_NAME_ALL]).map((path5) => [path5, r[METHOD_NAME_ALL][path5]])
+          ...Object.keys(r[METHOD_NAME_ALL]).map((path8) => [path8, r[METHOD_NAME_ALL][path8]])
         );
       }
     });
@@ -2379,13 +2379,13 @@ var SmartRouter = class {
   constructor(init) {
     this.#routers = init.routers;
   }
-  add(method, path5, handler) {
+  add(method, path8, handler) {
     if (!this.#routes) {
       throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
-    this.#routes.push([method, path5, handler]);
+    this.#routes.push([method, path8, handler]);
   }
-  match(method, path5) {
+  match(method, path8) {
     if (!this.#routes) {
       throw new Error("Fatal error");
     }
@@ -2400,7 +2400,7 @@ var SmartRouter = class {
         for (let i2 = 0, len2 = routes.length; i2 < len2; i2++) {
           router.add(...routes[i2]);
         }
-        res = router.match(method, path5);
+        res = router.match(method, path8);
       } catch (e) {
         if (e instanceof UnsupportedPathError) {
           continue;
@@ -2450,10 +2450,10 @@ var Node2 = class _Node2 {
     }
     this.#patterns = [];
   }
-  insert(method, path5, handler) {
+  insert(method, path8, handler) {
     this.#order = ++this.#order;
     let curNode = this;
-    const parts = splitRoutingPath(path5);
+    const parts = splitRoutingPath(path8);
     const possibleKeys = [];
     for (let i = 0, len = parts.length; i < len; i++) {
       const p = parts[i];
@@ -2502,12 +2502,12 @@ var Node2 = class _Node2 {
       }
     }
   }
-  search(method, path5) {
+  search(method, path8) {
     const handlerSets = [];
     this.#params = emptyParams;
     const curNode = this;
     let curNodes = [curNode];
-    const parts = splitPath(path5);
+    const parts = splitPath(path8);
     const curNodesQueue = [];
     const len = parts.length;
     let partOffsets = null;
@@ -2549,13 +2549,13 @@ var Node2 = class _Node2 {
           if (matcher instanceof RegExp) {
             if (partOffsets === null) {
               partOffsets = new Array(len);
-              let offset = path5[0] === "/" ? 1 : 0;
+              let offset = path8[0] === "/" ? 1 : 0;
               for (let p = 0; p < len; p++) {
                 partOffsets[p] = offset;
                 offset += parts[p].length + 1;
               }
             }
-            const restPathString = path5.substring(partOffsets[i]);
+            const restPathString = path8.substring(partOffsets[i]);
             const m = matcher.exec(restPathString);
             if (m) {
               params[name] = m[0];
@@ -2608,18 +2608,18 @@ var TrieRouter = class {
   constructor() {
     this.#node = new Node2();
   }
-  add(method, path5, handler) {
-    const results = checkOptionalParameter(path5);
+  add(method, path8, handler) {
+    const results = checkOptionalParameter(path8);
     if (results) {
       for (let i = 0, len = results.length; i < len; i++) {
         this.#node.insert(method, results[i], handler);
       }
       return;
     }
-    this.#node.insert(method, path5, handler);
+    this.#node.insert(method, path8, handler);
   }
-  match(method, path5) {
-    return this.#node.search(method, path5);
+  match(method, path8) {
+    return this.#node.search(method, path8);
   }
 };
 
@@ -2638,6 +2638,155 @@ var Hono2 = class extends Hono {
   }
 };
 
+// ../node_modules/.pnpm/hono@4.12.9/node_modules/hono/dist/utils/stream.js
+var StreamingApi = class {
+  writer;
+  encoder;
+  writable;
+  abortSubscribers = [];
+  responseReadable;
+  /**
+   * Whether the stream has been aborted.
+   */
+  aborted = false;
+  /**
+   * Whether the stream has been closed normally.
+   */
+  closed = false;
+  constructor(writable, _readable) {
+    this.writable = writable;
+    this.writer = writable.getWriter();
+    this.encoder = new TextEncoder();
+    const reader = _readable.getReader();
+    this.abortSubscribers.push(async () => {
+      await reader.cancel();
+    });
+    this.responseReadable = new ReadableStream({
+      async pull(controller) {
+        const { done, value } = await reader.read();
+        done ? controller.close() : controller.enqueue(value);
+      },
+      cancel: () => {
+        this.abort();
+      }
+    });
+  }
+  async write(input) {
+    try {
+      if (typeof input === "string") {
+        input = this.encoder.encode(input);
+      }
+      await this.writer.write(input);
+    } catch {
+    }
+    return this;
+  }
+  async writeln(input) {
+    await this.write(input + "\n");
+    return this;
+  }
+  sleep(ms) {
+    return new Promise((res) => setTimeout(res, ms));
+  }
+  async close() {
+    try {
+      await this.writer.close();
+    } catch {
+    }
+    this.closed = true;
+  }
+  async pipe(body) {
+    this.writer.releaseLock();
+    await body.pipeTo(this.writable, { preventClose: true });
+    this.writer = this.writable.getWriter();
+  }
+  onAbort(listener) {
+    this.abortSubscribers.push(listener);
+  }
+  /**
+   * Abort the stream.
+   * You can call this method when stream is aborted by external event.
+   */
+  abort() {
+    if (!this.aborted) {
+      this.aborted = true;
+      this.abortSubscribers.forEach((subscriber) => subscriber());
+    }
+  }
+};
+
+// ../node_modules/.pnpm/hono@4.12.9/node_modules/hono/dist/helper/streaming/utils.js
+var isOldBunVersion = () => {
+  const version2 = typeof Bun !== "undefined" ? Bun.version : void 0;
+  if (version2 === void 0) {
+    return false;
+  }
+  const result = version2.startsWith("1.1") || version2.startsWith("1.0") || version2.startsWith("0.");
+  isOldBunVersion = () => result;
+  return result;
+};
+
+// ../node_modules/.pnpm/hono@4.12.9/node_modules/hono/dist/helper/streaming/sse.js
+var SSEStreamingApi = class extends StreamingApi {
+  constructor(writable, readable) {
+    super(writable, readable);
+  }
+  async writeSSE(message) {
+    const data = await resolveCallback(message.data, HtmlEscapedCallbackPhase.Stringify, false, {});
+    const dataLines = data.split(/\r\n|\r|\n/).map((line) => {
+      return `data: ${line}`;
+    }).join("\n");
+    for (const key of ["event", "id", "retry"]) {
+      if (message[key] && /[\r\n]/.test(message[key])) {
+        throw new Error(`${key} must not contain "\\r" or "\\n"`);
+      }
+    }
+    const sseData = [
+      message.event && `event: ${message.event}`,
+      dataLines,
+      message.id && `id: ${message.id}`,
+      message.retry && `retry: ${message.retry}`
+    ].filter(Boolean).join("\n") + "\n\n";
+    await this.write(sseData);
+  }
+};
+var run = async (stream2, cb, onError) => {
+  try {
+    await cb(stream2);
+  } catch (e) {
+    if (e instanceof Error && onError) {
+      await onError(e, stream2);
+      await stream2.writeSSE({
+        event: "error",
+        data: e.message
+      });
+    } else {
+      console.error(e);
+    }
+  } finally {
+    stream2.close();
+  }
+};
+var contextStash = /* @__PURE__ */ new WeakMap();
+var streamSSE = (c, cb, onError) => {
+  const { readable, writable } = new TransformStream();
+  const stream2 = new SSEStreamingApi(writable, readable);
+  if (isOldBunVersion()) {
+    c.req.raw.signal.addEventListener("abort", () => {
+      if (!stream2.closed) {
+        stream2.abort();
+      }
+    });
+  }
+  contextStash.set(stream2.responseReadable, c);
+  c.header("Transfer-Encoding", "chunked");
+  c.header("Content-Type", "text/event-stream");
+  c.header("Cache-Control", "no-cache");
+  c.header("Connection", "keep-alive");
+  run(stream2, cb, onError);
+  return c.newResponse(stream2.responseReadable);
+};
+
 // ../node_modules/.pnpm/hono@4.12.9/node_modules/hono/dist/utils/mime.js
 var getMimeType = (filename, mimes = baseMimes) => {
   const regexp = /\.([a-zA-Z0-9]+?)$/;
@@ -2728,32 +2877,32 @@ var pr54206Applied = () => {
   return major >= 23 || major === 22 && minor >= 7 || major === 20 && minor >= 18;
 };
 var useReadableToWeb = pr54206Applied();
-var createStreamBody = (stream) => {
+var createStreamBody = (stream2) => {
   if (useReadableToWeb) {
-    return Readable2.toWeb(stream);
+    return Readable2.toWeb(stream2);
   }
   const body = new ReadableStream({
     start(controller) {
-      stream.on("data", (chunk) => {
+      stream2.on("data", (chunk) => {
         controller.enqueue(chunk);
       });
-      stream.on("error", (err) => {
+      stream2.on("error", (err) => {
         controller.error(err);
       });
-      stream.on("end", () => {
+      stream2.on("end", () => {
         controller.close();
       });
     },
     cancel() {
-      stream.destroy();
+      stream2.destroy();
     }
   });
   return body;
 };
-var getStats = (path5) => {
+var getStats = (path8) => {
   let stats;
   try {
-    stats = statSync(path5);
+    stats = statSync(path8);
   } catch {
   }
   return stats;
@@ -2796,21 +2945,21 @@ var serveStatic = (options = { root: "" }) => {
         return next();
       }
     }
-    let path5 = join(
+    let path8 = join(
       root,
       !optionPath && options.rewriteRequestPath ? options.rewriteRequestPath(filename, c) : filename
     );
-    let stats = getStats(path5);
+    let stats = getStats(path8);
     if (stats && stats.isDirectory()) {
       const indexFile = options.index ?? "index.html";
-      path5 = join(path5, indexFile);
-      stats = getStats(path5);
+      path8 = join(path8, indexFile);
+      stats = getStats(path8);
     }
     if (!stats) {
-      await options.onNotFound?.(path5, c);
+      await options.onNotFound?.(path8, c);
       return next();
     }
-    const mimeType = getMimeType(path5);
+    const mimeType = getMimeType(path8);
     c.header("Content-Type", mimeType || "application/octet-stream");
     if (options.precompressed && (!mimeType || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
       const acceptEncodingSet = new Set(
@@ -2820,12 +2969,12 @@ var serveStatic = (options = { root: "" }) => {
         if (!acceptEncodingSet.has(encoding)) {
           continue;
         }
-        const precompressedStats = getStats(path5 + ENCODINGS[encoding]);
+        const precompressedStats = getStats(path8 + ENCODINGS[encoding]);
         if (precompressedStats) {
           c.header("Content-Encoding", encoding);
           c.header("Vary", "Accept-Encoding", { append: true });
           stats = precompressedStats;
-          path5 = path5 + ENCODINGS[encoding];
+          path8 = path8 + ENCODINGS[encoding];
           break;
         }
       }
@@ -2839,7 +2988,7 @@ var serveStatic = (options = { root: "" }) => {
       result = c.body(null);
     } else if (!range) {
       c.header("Content-Length", size.toString());
-      result = c.body(createStreamBody(createReadStream(path5)), 200);
+      result = c.body(createStreamBody(createReadStream(path8)), 200);
     } else {
       c.header("Accept-Ranges", "bytes");
       c.header("Date", stats.birthtime.toUTCString());
@@ -2850,12 +2999,12 @@ var serveStatic = (options = { root: "" }) => {
         end = size - 1;
       }
       const chunksize = end - start + 1;
-      const stream = createReadStream(path5, { start, end });
+      const stream2 = createReadStream(path8, { start, end });
       c.header("Content-Length", chunksize.toString());
       c.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
-      result = c.body(createStreamBody(stream), 206);
+      result = c.body(createStreamBody(stream2), 206);
     }
-    await options.onFound?.(path5, c);
+    await options.onFound?.(path8, c);
     return result;
   };
 };
@@ -2924,6 +3073,154 @@ function loadChatVisibility(metadata2, opts) {
   };
 }
 
+// src/title.ts
+function deriveBaseTitle(firstUserText) {
+  const text2 = firstUserText?.trim().split("\n")[0]?.trim();
+  return text2 && text2.length > 0 ? text2 : "Untitled";
+}
+
+// src/list-pagination.ts
+import fs from "fs";
+import path from "path";
+import Database from "better-sqlite3";
+
+// src/list-filter.ts
+function buildFilterClauses({
+  projects,
+  tags: tags3,
+  hasMetadata
+}) {
+  const clauses = [];
+  const params = [];
+  if (projects && projects.length > 0) {
+    const placeholders = projects.map(() => "?").join(", ");
+    clauses.push(`coalesce(c.project, '') IN (${placeholders})`);
+    params.push(...projects);
+  }
+  if (tags3 && tags3.length > 0) {
+    const realTagIds = tags3.filter((t) => t !== "");
+    const wantUntagged = tags3.includes("");
+    if (realTagIds.length > 0) {
+      if (!hasMetadata) {
+        clauses.push("0");
+      } else {
+        const placeholders = realTagIds.map(() => "?").join(", ");
+        clauses.push(
+          `c.id IN (SELECT chat_id FROM meta.chat_tags
+                    WHERE tag_id IN (${placeholders})
+                    GROUP BY chat_id HAVING count(*) = ?)`
+        );
+        params.push(...realTagIds, realTagIds.length);
+      }
+    }
+    if (wantUntagged && hasMetadata) {
+      clauses.push("c.id NOT IN (SELECT chat_id FROM meta.chat_tags)");
+    }
+  }
+  return { clauses, params };
+}
+
+// src/list-pagination.ts
+var ARCHIVE_DB = "archive.db";
+var METADATA_DB = "metadata.db";
+var SORT_EXPR = {
+  createdAt: "c.created_at",
+  updatedAt: "c.updated_at",
+  deletedAt: "m.deleted_at",
+  // The Title axis orders by the precomputed collation key on the ATTACHed
+  // `meta.chat_sort_keys` (alias `k`), reached through the INNER JOIN added
+  // below (ADR-0019). BINARY compare over `sort_key` is an index range scan.
+  title: "k.sort_key"
+};
+function encodeCursor(cursor) {
+  return Buffer.from(JSON.stringify(cursor), "utf8").toString("base64url");
+}
+function decodeCursor(token) {
+  try {
+    const parsed = JSON.parse(
+      Buffer.from(token, "base64url").toString("utf8")
+    );
+    const sortKey = parsed?.sortKey;
+    if (parsed && typeof parsed === "object" && (typeof sortKey === "number" || typeof sortKey === "string") && typeof parsed.id === "string") {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function createChatPageQuery({
+  dataDir: dataDir2
+}) {
+  const archive2 = new Database(path.join(dataDir2, ARCHIVE_DB), {
+    readonly: true
+  });
+  const metadataPath = path.join(dataDir2, METADATA_DB);
+  const hasMetadata = fs.existsSync(metadataPath);
+  if (hasMetadata) {
+    archive2.prepare("ATTACH DATABASE ? AS meta").run(metadataPath);
+  }
+  function queryPage(query) {
+    const sortExpr = SORT_EXPR[query.sort];
+    const needsDeletedJoin = query.sort === "deletedAt";
+    const needsSortKeyJoin = query.sort === "title";
+    if ((needsDeletedJoin || needsSortKeyJoin) && !hasMetadata) {
+      return { items: [], nextCursor: null };
+    }
+    let from = "chats c";
+    if (needsDeletedJoin) from += " JOIN meta.chats_meta m ON m.id = c.id";
+    if (needsSortKeyJoin) from += " JOIN meta.chat_sort_keys k ON k.id = c.id";
+    const idCol = needsDeletedJoin ? "m.id" : needsSortKeyJoin ? "k.id" : "c.id";
+    const clauses = [];
+    const params = [];
+    if (needsDeletedJoin) {
+      clauses.push("m.deleted_at IS NOT NULL");
+    } else if (query.trashedOnly) {
+      if (!hasMetadata) return { items: [], nextCursor: null };
+      clauses.push(
+        "c.id IN (SELECT id FROM meta.chats_meta WHERE is_deleted = 1)"
+      );
+    } else if (!query.includeTrashed && hasMetadata) {
+      clauses.push(
+        "c.id NOT IN (SELECT id FROM meta.chats_meta WHERE is_deleted = 1)"
+      );
+    }
+    const filter = buildFilterClauses({
+      projects: query.projects,
+      tags: query.tags,
+      hasMetadata
+    });
+    clauses.push(...filter.clauses);
+    params.push(...filter.params);
+    const direction = query.direction ?? "desc";
+    const cmp = direction === "asc" ? ">" : "<";
+    const order = direction === "asc" ? "ASC" : "DESC";
+    if (query.cursor) {
+      clauses.push(
+        `(${sortExpr} ${cmp} ? OR (${sortExpr} = ? AND ${idCol} ${cmp} ?))`
+      );
+      params.push(query.cursor.sortKey, query.cursor.sortKey, query.cursor.id);
+    }
+    const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+    const rows = archive2.prepare(
+      `SELECT c.id AS id, ${sortExpr} AS sortKey
+         FROM ${from} ${where}
+         ORDER BY ${sortExpr} ${order}, ${idCol} ${order}
+         LIMIT ?`
+    ).all(...params, query.limit + 1);
+    const items = rows.slice(0, query.limit);
+    const last = items[items.length - 1];
+    const nextCursor = rows.length > query.limit && last ? { sortKey: last.sortKey, id: last.id } : null;
+    return { items, nextCursor };
+  }
+  return {
+    queryPage,
+    close() {
+      archive2.close();
+    }
+  };
+}
+
 // src/chat-reader.ts
 function toApiBlock(block) {
   if (block.type === "tool_result") {
@@ -2938,7 +3235,9 @@ function toApiBlock(block) {
 function createChatReader({
   archive: archive2,
   metadata: metadata2,
-  tags: tags3
+  tags: tags3,
+  pageQuery: pageQuery2,
+  countsQuery: countsQuery2
 }) {
   function findChat(id) {
     const code = parseChatId(id);
@@ -2947,8 +3246,7 @@ function createChatReader({
   }
   function deriveTitle(customTitle, firstUserText) {
     if (customTitle && customTitle.trim()) return customTitle;
-    const text2 = firstUserText?.trim().split("\n")[0]?.trim();
-    return text2 && text2.length > 0 ? text2 : "Untitled";
+    return deriveBaseTitle(firstUserText);
   }
   function key(agent, sourceId) {
     return [agent, sourceId].join("\0");
@@ -2972,22 +3270,28 @@ function createChatReader({
         return true;
       };
     }
+    const toResponse = loadHydration();
+    const chats2 = [];
+    for (const row of rows) {
+      if (!visibility.isVisible(row.id)) continue;
+      if (passesTagFilter && !passesTagFilter(row.id)) continue;
+      chats2.push(toResponse(row, visibility));
+    }
+    return chats2;
+  }
+  function loadHydration(scope) {
     const tsRangeByKey = new Map(
-      archive2.read.listChatTsRanges().map((r) => [key(r.agent, r.sourceId), r])
+      archive2.read.listChatTsRanges(scope).map((r) => [key(r.agent, r.sourceId), r])
     );
     const sourcePathByKey = new Map(
-      archive2.read.listLatestRawSourcePaths().map((r) => [key(r.agent, r.sourceId), r.sourcePath])
+      archive2.read.listLatestRawSourcePaths(scope).map((r) => [key(r.agent, r.sourceId), r.sourcePath])
     );
     const firstUserTextByKey = new Map(
-      archive2.read.listFirstUserTexts().map((r) => [key(r.agent, r.sourceId), r.text])
+      archive2.read.listFirstUserTexts(scope).map((r) => [key(r.agent, r.sourceId), r.text])
     );
     const customTitleById = metadata2.listCustomTitles();
     const tagsByChatId = tags3.listTagsByChat();
-    const chats2 = [];
-    for (const row of rows) {
-      if (!visibility.isVisible(row.id)) continue;
-      if (passesTagFilter && !passesTagFilter(row.id)) continue;
-      const isDeleted = visibility.isTrashed(row.id);
+    return (row, visibility) => {
       const rowKey = key(row.agent, row.sourceId);
       const tsRange = tsRangeByKey.get(rowKey);
       const firstSeenAtMs = row.firstSeenAt.getTime();
@@ -3007,10 +3311,70 @@ function createChatReader({
         deletedAt: visibility.deletedAt(row.id),
         tags: tagsByChatId.get(row.id) ?? []
       };
-      if (isDeleted) chat.isDeleted = true;
-      chats2.push(chat);
+      if (visibility.isTrashed(row.id)) chat.isDeleted = true;
+      return chat;
+    };
+  }
+  function listChatsPage({
+    sort,
+    direction,
+    limit,
+    cursor,
+    includeTrashed = false,
+    trashedOnly = false,
+    projects,
+    tags: tagSelection
+  }) {
+    if (!pageQuery2) {
+      throw new Error("listChatsPage requires a pageQuery dependency");
+    }
+    const decoded = cursor ? decodeCursor(cursor) ?? void 0 : void 0;
+    const page = pageQuery2.queryPage({
+      sort,
+      direction,
+      limit,
+      cursor: decoded,
+      includeTrashed,
+      trashedOnly,
+      projects,
+      tags: tagSelection
+    });
+    const visibility = loadChatVisibility(metadata2, {
+      includeTrashed: includeTrashed || trashedOnly
+    });
+    const pageIds = page.items.map((item) => item.id);
+    const rows = archive2.read.listChatRowsByIds(pageIds);
+    const rowById = new Map(rows.map((r) => [r.id, r]));
+    const toResponse = loadHydration({
+      sourceIds: rows.map((r) => r.sourceId)
+    });
+    const chats2 = [];
+    for (const item of page.items) {
+      const row = rowById.get(item.id);
+      if (row) chats2.push(toResponse(row, visibility));
     }
-    return chats2;
+    return {
+      chats: chats2,
+      nextCursor: page.nextCursor ? encodeCursor(page.nextCursor) : null
+    };
+  }
+  function listCounts({
+    includeTrashed = false
+  }) {
+    if (!countsQuery2) {
+      throw new Error("listCounts requires a countsQuery dependency");
+    }
+    return countsQuery2.queryCounts({ includeTrashed });
+  }
+  function listFilteredTotal({
+    includeTrashed = false,
+    projects,
+    tags: tags4
+  }) {
+    if (!countsQuery2) {
+      throw new Error("listFilteredTotal requires a countsQuery dependency");
+    }
+    return countsQuery2.queryFilteredTotal({ includeTrashed, projects, tags: tags4 });
   }
   function getMessages(id, { includeTrashed }) {
     const row = findChat(id);
@@ -3024,24 +3388,122 @@ function createChatReader({
       timestamp: m.ts.toISOString()
     }));
   }
-  return { listChats, getMessages, findChat };
+  return {
+    listChats,
+    listChatsPage,
+    listCounts,
+    listFilteredTotal,
+    getMessages,
+    findChat
+  };
 }
 
+// src/list-contract.ts
+var MAX_PAGE_LIMIT = 200;
+
 // src/app.ts
-function createApp({ archive: archive2, metadata: metadata2, tags: tags3, webDistDir: webDistDir2 }) {
+var STREAM_HEARTBEAT_MS = 25e3;
+function createApp({
+  archive: archive2,
+  metadata: metadata2,
+  tags: tags3,
+  pageQuery: pageQuery2,
+  countsQuery: countsQuery2,
+  listEvents: listEvents2,
+  webDistDir: webDistDir2
+}) {
   const app2 = new Hono2();
-  const reader = createChatReader({ archive: archive2, metadata: metadata2, tags: tags3 });
+  const reader = createChatReader({
+    archive: archive2,
+    metadata: metadata2,
+    tags: tags3,
+    pageQuery: pageQuery2,
+    countsQuery: countsQuery2
+  });
   app2.get("/api/chats", (c) => {
+    const includeTrashed = c.req.query("includeTrashed") === "true";
+    const limitParam = c.req.query("limit");
+    if (limitParam !== void 0) {
+      if (!pageQuery2) {
+        return c.json({ error: "Pagination is not available" }, 501);
+      }
+      const limit = Number.parseInt(limitParam, 10);
+      if (!Number.isInteger(limit) || limit <= 0 || limit > MAX_PAGE_LIMIT) {
+        return c.json({ error: "Invalid limit" }, 400);
+      }
+      const sort = c.req.query("sort") ?? "updatedAt";
+      if (sort !== "createdAt" && sort !== "updatedAt" && sort !== "deletedAt" && sort !== "title") {
+        return c.json({ error: "Invalid sort" }, 400);
+      }
+      const direction = c.req.query("direction") ?? "desc";
+      if (direction !== "asc" && direction !== "desc") {
+        return c.json({ error: "Invalid direction" }, 400);
+      }
+      const trashedOnly = c.req.query("trashedOnly") === "true";
+      const projects2 = c.req.queries("project");
+      const tagsParam2 = c.req.query("tags");
+      const tagSelection = tagsParam2 === void 0 ? void 0 : tagsParam2.split(",");
+      const { chats: chats3, nextCursor } = reader.listChatsPage({
+        sort,
+        direction,
+        limit,
+        cursor: c.req.query("cursor"),
+        includeTrashed,
+        trashedOnly,
+        projects: projects2,
+        tags: tagSelection
+      });
+      return c.json({ chats: chats3, nextCursor });
+    }
     const projects = c.req.queries("project");
     const tagsParam = c.req.query("tags");
     const tags4 = tagsParam === void 0 ? void 0 : tagsParam.split(",");
     const chats2 = reader.listChats({
-      includeTrashed: c.req.query("includeTrashed") === "true",
+      includeTrashed,
       projects,
       tags: tags4
     });
     return c.json({ chats: chats2 });
   });
+  app2.get("/api/chats/stream", (c) => {
+    if (!listEvents2) {
+      return c.json({ error: "Live updates are not available" }, 501);
+    }
+    const hub = listEvents2;
+    return streamSSE(c, async (stream2) => {
+      const unsubscribe = hub.subscribe((event) => {
+        void stream2.writeSSE({ event: event.type, data: "" });
+      });
+      await new Promise((resolve3) => {
+        const heartbeat = setInterval(() => {
+          void stream2.writeSSE({ event: "ping", data: "" });
+        }, STREAM_HEARTBEAT_MS);
+        stream2.onAbort(() => {
+          clearInterval(heartbeat);
+          unsubscribe();
+          resolve3();
+        });
+      });
+    });
+  });
+  app2.get("/api/chats/counts", (c) => {
+    if (!countsQuery2) {
+      return c.json({ error: "Counts are not available" }, 501);
+    }
+    const includeTrashed = c.req.query("includeTrashed") === "true";
+    return c.json(reader.listCounts({ includeTrashed }));
+  });
+  app2.get("/api/chats/list-total", (c) => {
+    if (!countsQuery2) {
+      return c.json({ error: "Counts are not available" }, 501);
+    }
+    const includeTrashed = c.req.query("includeTrashed") === "true";
+    const projects = c.req.queries("project");
+    const tagsParam = c.req.query("tags");
+    const tags4 = tagsParam === void 0 ? void 0 : tagsParam.split(",");
+    const total = reader.listFilteredTotal({ includeTrashed, projects, tags: tags4 });
+    return c.json({ total });
+  });
   app2.delete("/api/chats/:id", (c) => {
     const row = reader.findChat(c.req.param("id"));
     if (!row) {
@@ -4491,7 +4953,7 @@ var QueryPromise = class {
 function mapResultRow(columns, row, joinsNotNullableMap) {
   const nullifyMap = {};
   const result = columns.reduce(
-    (result2, { path: path5, field }, columnIndex) => {
+    (result2, { path: path8, field }, columnIndex) => {
       let decoder;
       if (is(field, Column)) {
         decoder = field;
@@ -4503,8 +4965,8 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
         decoder = field.sql.decoder;
       }
       let node = result2;
-      for (const [pathChunkIndex, pathChunk] of path5.entries()) {
-        if (pathChunkIndex < path5.length - 1) {
+      for (const [pathChunkIndex, pathChunk] of path8.entries()) {
+        if (pathChunkIndex < path8.length - 1) {
           if (!(pathChunk in node)) {
             node[pathChunk] = {};
           }
@@ -4512,8 +4974,8 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
         } else {
           const rawValue = row[columnIndex];
           const value = node[pathChunk] = rawValue === null ? null : decoder.mapFromDriverValue(rawValue);
-          if (joinsNotNullableMap && is(field, Column) && path5.length === 2) {
-            const objectName = path5[0];
+          if (joinsNotNullableMap && is(field, Column) && path8.length === 2) {
+            const objectName = path8[0];
             if (!(objectName in nullifyMap)) {
               nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
             } else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== getTableName(field.table)) {
@@ -5073,10 +5535,10 @@ function mapRelationalRow(tablesConfig, tableConfig, row, buildQueryResultSelect
 }
 
 // src/storage/openStore.ts
-import fs2 from "fs";
-import path from "path";
+import fs3 from "fs";
+import path2 from "path";
 import { fileURLToPath } from "url";
-import Database from "better-sqlite3";
+import Database2 from "better-sqlite3";
 
 // ../node_modules/.pnpm/drizzle-orm@0.45.2_@types+better-sqlite3@7.6.13_better-sqlite3@12.9.0/node_modules/drizzle-orm/better-sqlite3/driver.js
 import Client from "better-sqlite3";
@@ -8683,20 +9145,20 @@ function drizzle(...params) {
 
 // ../node_modules/.pnpm/drizzle-orm@0.45.2_@types+better-sqlite3@7.6.13_better-sqlite3@12.9.0/node_modules/drizzle-orm/migrator.js
 import crypto4 from "crypto";
-import fs from "fs";
+import fs2 from "fs";
 function readMigrationFiles(config) {
   const migrationFolderTo = config.migrationsFolder;
   const migrationQueries = [];
   const journalPath = `${migrationFolderTo}/meta/_journal.json`;
-  if (!fs.existsSync(journalPath)) {
+  if (!fs2.existsSync(journalPath)) {
     throw new Error(`Can't find meta/_journal.json file`);
   }
-  const journalAsString = fs.readFileSync(`${migrationFolderTo}/meta/_journal.json`).toString();
+  const journalAsString = fs2.readFileSync(`${migrationFolderTo}/meta/_journal.json`).toString();
   const journal = JSON.parse(journalAsString);
   for (const journalEntry of journal.entries) {
     const migrationPath = `${migrationFolderTo}/${journalEntry.tag}.sql`;
     try {
-      const query = fs.readFileSync(`${migrationFolderTo}/${journalEntry.tag}.sql`).toString();
+      const query = fs2.readFileSync(`${migrationFolderTo}/${journalEntry.tag}.sql`).toString();
       const result = query.split("--> statement-breakpoint").map((it) => {
         return it;
       });
@@ -8721,12 +9183,12 @@ function migrate(db, config) {
 
 // src/storage/openStore.ts
 function resolveMigrationsFolder(callerUrl, migrationsSubdir) {
-  const here = path.dirname(fileURLToPath(callerUrl));
+  const here = path2.dirname(fileURLToPath(callerUrl));
   const candidates = [
-    path.join(here, "../..", migrationsSubdir),
-    path.join(here, ".", migrationsSubdir)
+    path2.join(here, "../..", migrationsSubdir),
+    path2.join(here, ".", migrationsSubdir)
   ];
-  const found = candidates.find((p) => fs2.existsSync(p));
+  const found = candidates.find((p) => fs3.existsSync(p));
   if (!found) {
     throw new Error(`Could not locate migrations folder "${migrationsSubdir}"`);
   }
@@ -8740,8 +9202,8 @@ function openStore({
   schema
 }) {
   const migrationsFolder = resolveMigrationsFolder(callerUrl, migrationsSubdir);
-  fs2.mkdirSync(dataDir2, { recursive: true });
-  const sqlite = new Database(path.join(dataDir2, dbFile));
+  fs3.mkdirSync(dataDir2, { recursive: true });
+  const sqlite = new Database2(path2.join(dataDir2, dbFile));
   const db = drizzle(sqlite, { schema });
   migrate(db, { migrationsFolder });
   return { db, sqlite };
@@ -8774,13 +9236,32 @@ var chats = sqliteTable(
     agent: text("agent").notNull(),
     sourceId: text("source_id").notNull(),
     firstSeenAt: integer("first_seen_at", { mode: "timestamp_ms" }).notNull(),
+    // Denormalized "conversation start" = min(messages.ts), kept current at
+    // ingest and backfilled in migration 0010. The createdAt sort pages by this
+    // (not first_seen_at, the ingest time) so the paged order matches the
+    // reader's displayed createdAt (issue #143, reconciling ADR-0017's caveat).
+    // Initialized to first_seen_at for a chat with no messages; since
+    // first_seen_at is the ingest time and so >= every message ts, the running
+    // min over (first_seen_at, message ts) equals min(messages.ts) once any
+    // message exists, and first_seen_at when none — never NULL.
+    createdAt: integer("created_at", { mode: "timestamp_ms" }),
+    // Denormalized "most recent activity" = max(messages.ts), kept current at
+    // ingest and backfilled in migration 0009. Lets the activity sort run as a
+    // keyset index range scan instead of an aggregate that defeats the index
+    // (ADR-0017). Initialized to first_seen_at for a chat with no messages, so
+    // it is never NULL and always agrees with the reader's derived `updatedAt`.
+    updatedAt: integer("updated_at", { mode: "timestamp_ms" }),
     project: text("project"),
     projectPath: text("project_path")
   },
   (t) => [
     uniqueIndex("chats_agent_source_idx").on(t.agent, t.sourceId),
     // Backs the server-side Project filter (`WHERE coalesce(project,'') IN …`).
-    index("chats_project_idx").on(t.project)
+    index("chats_project_idx").on(t.project),
+    // Covering keyset indexes for the two server-side list sorts (ADR-0017):
+    // (sortKey, id) so the ORDER BY + LIMIT is an index range scan either way.
+    index("chats_created_keyset_idx").on(t.createdAt, t.id),
+    index("chats_updated_keyset_idx").on(t.updatedAt, t.id)
   ]
 );
 var rawMessages = sqliteTable(
@@ -8836,6 +9317,10 @@ function createArchiveReadSeam(db) {
       }
       return db.select().from(chats).all();
     },
+    listChatRowsByIds(ids) {
+      if (ids.length === 0) return [];
+      return db.select().from(chats).where(inArray(chats.id, ids)).all();
+    },
     findChatBySourceId(sourceId) {
       return db.select().from(chats).where(eq(chats.sourceId, sourceId)).get() ?? null;
     },
@@ -8845,15 +9330,17 @@ function createArchiveReadSeam(db) {
     listMessagesByChat(agent, sourceId) {
       return db.select().from(messages).where(and(eq(messages.agent, agent), eq(messages.sourceId, sourceId))).orderBy(asc(messages.ts)).all();
     },
-    listChatTsRanges() {
+    listChatTsRanges(opts) {
+      const scope = opts?.sourceIds !== void 0 ? inArray(messages.sourceId, opts.sourceIds) : sql`1 = 1`;
       return db.select({
         agent: messages.agent,
         sourceId: messages.sourceId,
         minTs: sql`min(${messages.ts})`,
         maxTs: sql`max(${messages.ts})`
-      }).from(messages).groupBy(messages.agent, messages.sourceId).all();
+      }).from(messages).where(scope).groupBy(messages.agent, messages.sourceId).all();
     },
-    listLatestRawSourcePaths() {
+    listLatestRawSourcePaths(opts) {
+      const scope = opts?.sourceIds !== void 0 ? inArray(rawMessages.sourceId, opts.sourceIds) : sql`1 = 1`;
       const ranked = db.select({
         agent: rawMessages.agent,
         sourceId: rawMessages.sourceId,
@@ -8861,14 +9348,18 @@ function createArchiveReadSeam(db) {
         rn: sql`row_number() over (partition by ${rawMessages.agent}, ${rawMessages.sourceId} order by ${rawMessages.ingestedAt} desc)`.as(
           "rn"
         )
-      }).from(rawMessages).as("ranked_raw");
+      }).from(rawMessages).where(scope).as("ranked_raw");
       return db.select({
         agent: ranked.agent,
         sourceId: ranked.sourceId,
         sourcePath: ranked.sourcePath
       }).from(ranked).where(eq(ranked.rn, 1)).all();
     },
-    listFirstUserTexts() {
+    listFirstUserTexts(opts) {
+      const scope = opts?.sourceIds !== void 0 ? and(
+        eq(messages.role, "user"),
+        inArray(messages.sourceId, opts.sourceIds)
+      ) : eq(messages.role, "user");
       const ranked = db.select({
         agent: messages.agent,
         sourceId: messages.sourceId,
@@ -8876,7 +9367,7 @@ function createArchiveReadSeam(db) {
         rn: sql`row_number() over (partition by ${messages.agent}, ${messages.sourceId} order by ${messages.ts} asc)`.as(
           "rn"
         )
-      }).from(messages).where(eq(messages.role, "user")).as("ranked_user");
+      }).from(messages).where(scope).as("ranked_user");
       return db.select({
         agent: ranked.agent,
         sourceId: ranked.sourceId,
@@ -8959,6 +9450,12 @@ function createArchiveRepository({
         agent,
         sourceId,
         firstSeenAt,
+        // Seed both denormalized sort keys to first_seen_at; message upserts
+        // pull createdAt down (min) and push updatedAt up (max) as ts arrive.
+        // first_seen_at is the ingest time and so >= every message ts, making
+        // it a safe upper bound for the running min.
+        createdAt: firstSeenAt,
+        updatedAt: firstSeenAt,
         project: project ?? null,
         projectPath: projectPath ?? null
       }).run();
@@ -8995,6 +9492,10 @@ function createArchiveRepository({
         )
       ).get();
       const ts = parseTs(message.ts);
+      db.update(chats).set({
+        createdAt: sql`min(coalesce(${chats.createdAt}, ${ts.getTime()}), ${ts.getTime()})`,
+        updatedAt: sql`max(coalesce(${chats.updatedAt}, 0), ${ts.getTime()})`
+      }).where(and(eq(chats.agent, agent), eq(chats.sourceId, sourceId))).run();
       if (!existing2) {
         db.insert(messages).values({
           agent,
@@ -9115,26 +9616,53 @@ function createCheckpointRepository({
 }
 
 // src/metadata/repository.ts
-import fs3 from "fs";
-import path2 from "path";
+import fs4 from "fs";
+import path3 from "path";
 
 // src/metadata/schema.ts
 var schema_exports3 = {};
 __export(schema_exports3, {
+  chatSortKeys: () => chatSortKeys,
   chatTags: () => chatTags,
   chatsMeta: () => chatsMeta,
   tags: () => tags
 });
-var chatsMeta = sqliteTable("chats_meta", {
-  id: text("id").primaryKey(),
-  isDeleted: integer("is_deleted", { mode: "boolean" }).notNull().default(false),
-  customTitle: text("custom_title"),
-  createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull(),
-  updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull(),
-  // Set when a chat is moved to Trash; null while active. Drives the Trash
-  // view's independent "Deleted time" sort axis.
-  deletedAt: integer("deleted_at", { mode: "timestamp_ms" })
-});
+var chatsMeta = sqliteTable(
+  "chats_meta",
+  {
+    id: text("id").primaryKey(),
+    isDeleted: integer("is_deleted", { mode: "boolean" }).notNull().default(false),
+    customTitle: text("custom_title"),
+    createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull(),
+    updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull(),
+    // Set when a chat is moved to Trash; null while active. Drives the Trash
+    // view's independent "Deleted time" sort axis.
+    deletedAt: integer("deleted_at", { mode: "timestamp_ms" })
+  },
+  (table) => [
+    // Covering keyset index for the Trash view's deleted-time axis (#145,
+    // ADR-0017): `(deleted_at, id)` so the page's ORDER BY + LIMIT is an index
+    // range scan, not a full-trash sort. Partial on `deleted_at IS NOT NULL`,
+    // which holds exactly for trashed rows (restore nulls it), so the index
+    // carries only the Trash set and the page query's matching predicate lets
+    // the planner use it.
+    index("chats_meta_deleted_at_idx").on(table.deletedAt, table.id).where(sql`${table.deletedAt} is not null`)
+  ]
+);
+var chatSortKeys = sqliteTable(
+  "chat_sort_keys",
+  {
+    id: text("id").primaryKey(),
+    textKey: text("text_key"),
+    sortKey: text("sort_key")
+  },
+  (table) => [
+    // Covering keyset index for the Title axis (ADR-0017/0019): `(sort_key, id)`
+    // so `ORDER BY sort_key, id` + LIMIT is an index range scan either
+    // direction, exactly like the time axes — never a full-table sort.
+    index("chat_sort_keys_sort_key_idx").on(table.sortKey, table.id)
+  ]
+);
 var tags = sqliteTable("tags", {
   id: text("id").primaryKey(),
   name: text("name").notNull(),
@@ -9154,15 +9682,26 @@ var chatTags = sqliteTable(
   ]
 );
 
+// src/metadata/title-sort-key.ts
+function encodeNumericRun(run2) {
+  const core = run2.replace(/^0+(?=\d)/, "");
+  const len = String(core.length);
+  return String(len.length) + len + core;
+}
+function computeSortKey(input) {
+  const folded = input.normalize("NFKD").toLowerCase().replace(/\p{M}+/gu, "");
+  return folded.replace(/\d+/g, encodeNumericRun);
+}
+
 // src/metadata/repository.ts
 var DB_FILE = "metadata.db";
 var LEGACY_DB_FILE = "data.db";
 function migrateLegacyDbFile(dataDir2) {
-  const legacy = path2.join(dataDir2, LEGACY_DB_FILE);
-  const current = path2.join(dataDir2, DB_FILE);
-  if (!fs3.existsSync(legacy)) return;
-  if (fs3.existsSync(current)) return;
-  fs3.renameSync(legacy, current);
+  const legacy = path3.join(dataDir2, LEGACY_DB_FILE);
+  const current = path3.join(dataDir2, DB_FILE);
+  if (!fs4.existsSync(legacy)) return;
+  if (fs4.existsSync(current)) return;
+  fs4.renameSync(legacy, current);
 }
 var CLAUDE_CODE_AGENT = "claude-code";
 function createMetadataRepository({
@@ -9234,6 +9773,27 @@ function createMetadataRepository({
         target: chatsMeta.id,
         set: { customTitle: title, updatedAt: now }
       }).run();
+      if (title !== null) {
+        const sortKey = computeSortKey(title);
+        db.insert(chatSortKeys).values({ id: internalId, sortKey }).onConflictDoUpdate({ target: chatSortKeys.id, set: { sortKey } }).run();
+      } else {
+        db.update(chatSortKeys).set({ sortKey: sql`${chatSortKeys.textKey}` }).where(eq(chatSortKeys.id, internalId)).run();
+      }
+    },
+    getTitleSortKey(internalId) {
+      const row = db.select({
+        textKey: chatSortKeys.textKey,
+        sortKey: chatSortKeys.sortKey
+      }).from(chatSortKeys).where(eq(chatSortKeys.id, internalId)).get();
+      return row ?? null;
+    },
+    setTitleTextKey(internalId, textKey) {
+      const customTitle = db.select({ customTitle: chatsMeta.customTitle }).from(chatsMeta).where(eq(chatsMeta.id, internalId)).get()?.customTitle;
+      const sortKey = customTitle && customTitle.trim() ? computeSortKey(customTitle) : textKey;
+      db.insert(chatSortKeys).values({ id: internalId, textKey, sortKey }).onConflictDoUpdate({
+        target: chatSortKeys.id,
+        set: { textKey, sortKey }
+      }).run();
     }
   };
 }
@@ -9345,7 +9905,7 @@ function createTagRepository({
 }
 
 // src/ingestion/ingest.ts
-import fs4 from "fs";
+import fs5 from "fs";
 async function runIngestion(opts) {
   const now = opts.now ?? (() => /* @__PURE__ */ new Date());
   const result = {
@@ -9405,7 +9965,7 @@ async function runIngestion(opts) {
 }
 function safeStat(p) {
   try {
-    return fs4.statSync(p);
+    return fs5.statSync(p);
   } catch {
     return null;
   }
@@ -9514,7 +10074,7 @@ var ReaddirpStream = class extends Readable3 {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path5) => statMethod(path5, { bigint: true });
+      this._stat = (path8) => statMethod(path8, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -9539,8 +10099,8 @@ var ReaddirpStream = class extends Readable3 {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path5, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path5));
+          const { path: path8, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path8));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -9580,20 +10140,20 @@ var ReaddirpStream = class extends Readable3 {
       this.reading = false;
     }
   }
-  async _exploreDir(path5, depth) {
+  async _exploreDir(path8, depth) {
     let files;
     try {
-      files = await readdir(path5, this._rdOptions);
+      files = await readdir(path8, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path5 };
+    return { files, depth, path: path8 };
   }
-  async _formatEntry(dirent, path5) {
+  async _formatEntry(dirent, path8) {
     let entry;
     const basename3 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path5, basename3));
+      const fullPath = presolve(pjoin(path8, basename3));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename3 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -9993,16 +10553,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path5, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path8, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path5);
-    emitRaw(rawEvent, evPath, { watchedPath: path5 });
-    if (evPath && path5 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path5, evPath), KEY_LISTENERS, sp.join(path5, evPath));
+    listener(path8);
+    emitRaw(rawEvent, evPath, { watchedPath: path8 });
+    if (evPath && path8 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path8, evPath), KEY_LISTENERS, sp.join(path8, evPath));
     }
   };
   try {
-    return fs_watch(path5, {
+    return fs_watch(path8, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -10018,12 +10578,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path5, fullPath, options, handlers) => {
+var setFsWatchListener = (path8, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher2;
   if (!options.persistent) {
-    watcher2 = createFsWatchInstance(path5, options, listener, errHandler, rawEmitter);
+    watcher2 = createFsWatchInstance(path8, options, listener, errHandler, rawEmitter);
     if (!watcher2)
       return;
     return watcher2.close.bind(watcher2);
@@ -10034,7 +10594,7 @@ var setFsWatchListener = (path5, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher2 = createFsWatchInstance(
-      path5,
+      path8,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -10049,7 +10609,7 @@ var setFsWatchListener = (path5, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path5, "r");
+          const fd = await open(path8, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -10080,7 +10640,7 @@ var setFsWatchListener = (path5, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path5, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path8, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -10102,7 +10662,7 @@ var setFsWatchFileListener = (path5, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path5, curr));
+          foreach(cont.listeners, (listener2) => listener2(path8, curr));
         }
       })
     };
@@ -10132,13 +10692,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path5, listener) {
+  _watchWithNodeFs(path8, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path5);
-    const basename3 = sp.basename(path5);
+    const directory = sp.dirname(path8);
+    const basename3 = sp.basename(path8);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename3);
-    const absolutePath = sp.resolve(path5);
+    const absolutePath = sp.resolve(path8);
     const options = {
       persistent: opts.persistent
     };
@@ -10148,12 +10708,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename3) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path5, absolutePath, options, {
+      closer = setFsWatchFileListener(path8, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path5, absolutePath, options, {
+      closer = setFsWatchListener(path8, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -10175,7 +10735,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename3))
       return;
-    const listener = async (path5, newStats) => {
+    const listener = async (path8, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -10189,11 +10749,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path5);
+            this.fsw._closeFile(path8);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path5, closer2);
+              this.fsw._addPathCloser(path8, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -10225,7 +10785,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path5, item) {
+  async _handleSymlink(entry, directory, path8, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -10235,7 +10795,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path5);
+        linkPath = await fsrealpath(path8);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -10245,12 +10805,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path5, entry.stats);
+          this.fsw._emit(EV.CHANGE, path8, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path5, entry.stats);
+        this.fsw._emit(EV.ADD, path8, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -10268,39 +10828,39 @@ var NodeFsHandler = class {
       return;
     const previous = this.fsw._getWatchedDir(wh.path);
     const current = /* @__PURE__ */ new Set();
-    let stream = this.fsw._readdirp(directory, {
+    let stream2 = this.fsw._readdirp(directory, {
       fileFilter: (entry) => wh.filterPath(entry),
       directoryFilter: (entry) => wh.filterDir(entry)
     });
-    if (!stream)
+    if (!stream2)
       return;
-    stream.on(STR_DATA, async (entry) => {
+    stream2.on(STR_DATA, async (entry) => {
       if (this.fsw.closed) {
-        stream = void 0;
+        stream2 = void 0;
         return;
       }
       const item = entry.path;
-      let path5 = sp.join(directory, item);
+      let path8 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path5, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path8, item)) {
         return;
       }
       if (this.fsw.closed) {
-        stream = void 0;
+        stream2 = void 0;
         return;
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path5 = sp.join(dir, sp.relative(dir, path5));
-        this._addToNodeFs(path5, initialAdd, wh, depth + 1);
+        path8 = sp.join(dir, sp.relative(dir, path8));
+        this._addToNodeFs(path8, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve3, reject) => {
-      if (!stream)
+      if (!stream2)
         return reject();
-      stream.once(STR_END, () => {
+      stream2.once(STR_END, () => {
         if (this.fsw.closed) {
-          stream = void 0;
+          stream2 = void 0;
           return;
         }
         const wasThrottled = throttler ? throttler.clear() : false;
@@ -10310,7 +10870,7 @@ var NodeFsHandler = class {
         }).forEach((item) => {
           this.fsw._remove(directory, item);
         });
-        stream = void 0;
+        stream2 = void 0;
         if (wasThrottled)
           this._handleRead(directory, false, wh, target, dir, depth, throttler);
       });
@@ -10361,13 +10921,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path5, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path8, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path5) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path8) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path5);
+    const wh = this.fsw._getWatchHelpers(path8);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -10383,8 +10943,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path5);
-        const targetPath = follow ? await fsrealpath(path5) : path5;
+        const absPath = sp.resolve(path8);
+        const targetPath = follow ? await fsrealpath(path8) : path8;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -10394,29 +10954,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path5) : path5;
+        const targetPath = follow ? await fsrealpath(path8) : path8;
         if (this.fsw.closed)
           return;
         const parent = sp.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path5, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path8, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path5), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path8), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path5, closer);
+        this.fsw._addPathCloser(path8, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path5;
+        return path8;
       }
     }
   }
@@ -10459,24 +11019,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path5) {
-  if (typeof path5 !== "string")
+function normalizePath(path8) {
+  if (typeof path8 !== "string")
     throw new Error("string expected");
-  path5 = sp2.normalize(path5);
-  path5 = path5.replace(/\\/g, "/");
+  path8 = sp2.normalize(path8);
+  path8 = path8.replace(/\\/g, "/");
   let prepend = false;
-  if (path5.startsWith("//"))
+  if (path8.startsWith("//"))
     prepend = true;
-  path5 = path5.replace(DOUBLE_SLASH_RE, "/");
+  path8 = path8.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path5 = "/" + path5;
-  return path5;
+    path8 = "/" + path8;
+  return path8;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path5 = normalizePath(testString);
+  const path8 = normalizePath(testString);
   for (let index2 = 0; index2 < patterns.length; index2++) {
     const pattern = patterns[index2];
-    if (pattern(path5, stats)) {
+    if (pattern(path8, stats)) {
       return true;
     }
   }
@@ -10514,19 +11074,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path5) => toUnix(sp2.normalize(toUnix(path5)));
-var normalizeIgnored = (cwd = "") => (path5) => {
-  if (typeof path5 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path5) ? path5 : sp2.join(cwd, path5));
+var normalizePathToUnix = (path8) => toUnix(sp2.normalize(toUnix(path8)));
+var normalizeIgnored = (cwd = "") => (path8) => {
+  if (typeof path8 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path8) ? path8 : sp2.join(cwd, path8));
   } else {
-    return path5;
+    return path8;
   }
 };
-var getAbsolutePath = (path5, cwd) => {
-  if (sp2.isAbsolute(path5)) {
-    return path5;
+var getAbsolutePath = (path8, cwd) => {
+  if (sp2.isAbsolute(path8)) {
+    return path8;
   }
-  return sp2.join(cwd, path5);
+  return sp2.join(cwd, path8);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -10591,10 +11151,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path5, follow, fsw) {
+  constructor(path8, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path5;
-    this.path = path5 = path5.replace(REPLACER_RE, "");
+    const watchPath = path8;
+    this.path = path8 = path8.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -10734,20 +11294,20 @@ var FSWatcher = class extends EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path5) => {
-        const absPath = getAbsolutePath(path5, cwd);
+      paths = paths.map((path8) => {
+        const absPath = getAbsolutePath(path8, cwd);
         return absPath;
       });
     }
-    paths.forEach((path5) => {
-      this._removeIgnoredPath(path5);
+    paths.forEach((path8) => {
+      this._removeIgnoredPath(path8);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path5) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path5, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path8) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path8, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -10769,17 +11329,17 @@ var FSWatcher = class extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path5) => {
-      if (!sp2.isAbsolute(path5) && !this._closers.has(path5)) {
+    paths.forEach((path8) => {
+      if (!sp2.isAbsolute(path8) && !this._closers.has(path8)) {
         if (cwd)
-          path5 = sp2.join(cwd, path5);
-        path5 = sp2.resolve(path5);
+          path8 = sp2.join(cwd, path8);
+        path8 = sp2.resolve(path8);
       }
-      this._closePath(path5);
-      this._addIgnoredPath(path5);
-      if (this._watched.has(path5)) {
+      this._closePath(path8);
+      this._addIgnoredPath(path8);
+      if (this._watched.has(path8)) {
         this._addIgnoredPath({
-          path: path5,
+          path: path8,
           recursive: true
         });
       }
@@ -10802,7 +11362,7 @@ var FSWatcher = class extends EventEmitter {
       if (promise instanceof Promise)
         closers.push(promise);
     }));
-    this._streams.forEach((stream) => stream.destroy());
+    this._streams.forEach((stream2) => stream2.destroy());
     this._userIgnored = void 0;
     this._readyCount = 0;
     this._readyEmitted = false;
@@ -10843,38 +11403,38 @@ var FSWatcher = class extends EventEmitter {
    * @param stats arguments to be passed with event
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
-  async _emit(event, path5, stats) {
+  async _emit(event, path8, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path5 = sp2.normalize(path5);
+      path8 = sp2.normalize(path8);
     if (opts.cwd)
-      path5 = sp2.relative(opts.cwd, path5);
-    const args = [path5];
+      path8 = sp2.relative(opts.cwd, path8);
+    const args = [path8];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path5))) {
+    if (awf && (pw = this._pendingWrites.get(path8))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path5, [event, ...args]);
+        this._pendingUnlinks.set(path8, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path6) => {
+          this._pendingUnlinks.forEach((entry, path9) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path6);
+            this._pendingUnlinks.delete(path9);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path5)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path8)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path5);
+        this._pendingUnlinks.delete(path8);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -10892,16 +11452,16 @@ var FSWatcher = class extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path5, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path8, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path5, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path8, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sp2.join(opts.cwd, path5) : path5;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path8) : path8;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -10932,23 +11492,23 @@ var FSWatcher = class extends EventEmitter {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path5, timeout) {
+  _throttle(actionType, path8, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, /* @__PURE__ */ new Map());
     }
     const action2 = this._throttled.get(actionType);
     if (!action2)
       throw new Error("invalid throttle");
-    const actionPath = action2.get(path5);
+    const actionPath = action2.get(path8);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action2.get(path5);
+      const item = action2.get(path8);
       const count = item ? item.count : 0;
-      action2.delete(path5);
+      action2.delete(path8);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -10956,7 +11516,7 @@ var FSWatcher = class extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action2.set(path5, thr);
+    action2.set(path8, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -10970,44 +11530,44 @@ var FSWatcher = class extends EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path5, threshold, event, awfEmit) {
+  _awaitWriteFinish(path8, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path5;
-    if (this.options.cwd && !sp2.isAbsolute(path5)) {
-      fullPath = sp2.join(this.options.cwd, path5);
+    let fullPath = path8;
+    if (this.options.cwd && !sp2.isAbsolute(path8)) {
+      fullPath = sp2.join(this.options.cwd, path8);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path5)) {
+        if (err || !writes.has(path8)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path5).lastChange = now2;
+          writes.get(path8).lastChange = now2;
         }
-        const pw = writes.get(path5);
+        const pw = writes.get(path8);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path5);
+          writes.delete(path8);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path5)) {
-      writes.set(path5, {
+    if (!writes.has(path8)) {
+      writes.set(path8, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path5);
+          writes.delete(path8);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -11018,8 +11578,8 @@ var FSWatcher = class extends EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path5, stats) {
-    if (this.options.atomic && DOT_RE.test(path5))
+  _isIgnored(path8, stats) {
+    if (this.options.atomic && DOT_RE.test(path8))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -11029,17 +11589,17 @@ var FSWatcher = class extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path5, stats);
+    return this._userIgnored(path8, stats);
   }
-  _isntIgnored(path5, stat4) {
-    return !this._isIgnored(path5, stat4);
+  _isntIgnored(path8, stat4) {
+    return !this._isIgnored(path8, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path5) {
-    return new WatchHelper(path5, this.options.followSymlinks, this);
+  _getWatchHelpers(path8) {
+    return new WatchHelper(path8, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -11071,63 +11631,63 @@ var FSWatcher = class extends EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path5 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path5);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path5) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path5, 100))
+    const path8 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path8);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path8) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path8, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path5);
+    const wp = this._getWatchedDir(path8);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path5, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path8, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path5;
+    let relPath = path8;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path5);
+      relPath = sp2.relative(this.options.cwd, path8);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path5);
+    this._watched.delete(path8);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path5))
-      this._emit(eventName, path5);
-    this._closePath(path5);
+    if (wasTracked && !this._isIgnored(path8))
+      this._emit(eventName, path8);
+    this._closePath(path8);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path5) {
-    this._closeFile(path5);
-    const dir = sp2.dirname(path5);
-    this._getWatchedDir(dir).remove(sp2.basename(path5));
+  _closePath(path8) {
+    this._closeFile(path8);
+    const dir = sp2.dirname(path8);
+    this._getWatchedDir(dir).remove(sp2.basename(path8));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path5) {
-    const closers = this._closers.get(path5);
+  _closeFile(path8) {
+    const closers = this._closers.get(path8);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path5);
+    this._closers.delete(path8);
   }
-  _addPathCloser(path5, closer) {
+  _addPathCloser(path8, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path5);
+    let list = this._closers.get(path8);
     if (!list) {
       list = [];
-      this._closers.set(path5, list);
+      this._closers.set(path8, list);
     }
     list.push(closer);
   }
@@ -11135,18 +11695,18 @@ var FSWatcher = class extends EventEmitter {
     if (this.closed)
       return;
     const options = { type: EVENTS.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
-    let stream = readdirp(root, options);
-    this._streams.add(stream);
-    stream.once(STR_CLOSE, () => {
-      stream = void 0;
+    let stream2 = readdirp(root, options);
+    this._streams.add(stream2);
+    stream2.once(STR_CLOSE, () => {
+      stream2 = void 0;
     });
-    stream.once(STR_END, () => {
-      if (stream) {
-        this._streams.delete(stream);
-        stream = void 0;
+    stream2.once(STR_END, () => {
+      if (stream2) {
+        this._streams.delete(stream2);
+        stream2 = void 0;
       }
     });
-    return stream;
+    return stream2;
   }
 };
 function watch(paths, options = {}) {
@@ -11225,13 +11785,13 @@ function startWatcher(opts) {
   }
   return {
     ready,
-    notifyChange(path5) {
-      if (watcher2) watcher2.emit("change", path5);
-      else scheduleIngest(path5);
+    notifyChange(path8) {
+      if (watcher2) watcher2.emit("change", path8);
+      else scheduleIngest(path8);
     },
-    notifyUnlink(path5) {
-      if (watcher2) watcher2.emit("unlink", path5);
-      else recordUnlink(path5);
+    notifyUnlink(path8) {
+      if (watcher2) watcher2.emit("unlink", path8);
+      else recordUnlink(path8);
     },
     async close() {
       closed = true;
@@ -11243,39 +11803,39 @@ function startWatcher(opts) {
 }
 
 // src/plugins/claude-code/plugin.ts
-import fs5 from "fs";
-import path3 from "path";
+import fs6 from "fs";
+import path4 from "path";
 import readline from "readline";
 var ClaudeCodePlugin = class {
   id = "claude-code";
   displayName = "Claude Code";
   async *discover(env) {
-    const projectsDir = path3.join(env.homeDir, ".claude", "projects");
-    if (!fs5.existsSync(projectsDir)) return;
-    const projects = fs5.readdirSync(projectsDir, { withFileTypes: true });
+    const projectsDir = path4.join(env.homeDir, ".claude", "projects");
+    if (!fs6.existsSync(projectsDir)) return;
+    const projects = fs6.readdirSync(projectsDir, { withFileTypes: true });
     for (const project of projects) {
       if (!project.isDirectory()) continue;
-      const projectPath = path3.join(projectsDir, project.name);
-      const files = fs5.readdirSync(projectPath, { withFileTypes: true });
+      const projectPath = path4.join(projectsDir, project.name);
+      const files = fs6.readdirSync(projectPath, { withFileTypes: true });
       for (const file of files) {
         if (!file.isFile() || !file.name.endsWith(".jsonl")) continue;
-        const sourcePath = path3.join(projectPath, file.name);
+        const sourcePath = path4.join(projectPath, file.name);
         const sourceId = file.name.replace(/\.jsonl$/, "");
         const cwd = await readCwdFromJsonl(sourcePath);
         yield {
           sourceId,
           sourcePath,
           watchPaths: [sourcePath],
-          project: cwd ? path3.basename(cwd) : void 0,
+          project: cwd ? path4.basename(cwd) : void 0,
           projectPath: cwd ?? void 0
         };
       }
     }
   }
   async *extractRaw(ref) {
-    if (!fs5.existsSync(ref.sourcePath)) return;
-    const stream = fs5.createReadStream(ref.sourcePath, { encoding: "utf-8" });
-    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    if (!fs6.existsSync(ref.sourcePath)) return;
+    const stream2 = fs6.createReadStream(ref.sourcePath, { encoding: "utf-8" });
+    const rl = readline.createInterface({ input: stream2, crlfDelay: Infinity });
     let lineNo = 0;
     for await (const line of rl) {
       lineNo += 1;
@@ -11323,8 +11883,8 @@ var ClaudeCodePlugin = class {
 };
 async function readCwdFromJsonl(sourcePath) {
   try {
-    const stream = fs5.createReadStream(sourcePath, { encoding: "utf-8" });
-    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    const stream2 = fs6.createReadStream(sourcePath, { encoding: "utf-8" });
+    const rl = readline.createInterface({ input: stream2, crlfDelay: Infinity });
     try {
       for await (const line of rl) {
         if (!line) continue;
@@ -11340,7 +11900,7 @@ async function readCwdFromJsonl(sourcePath) {
       }
     } finally {
       rl.close();
-      stream.destroy();
+      stream2.destroy();
     }
   } catch {
   }
@@ -11429,10 +11989,131 @@ Environment:
   PORT=<n>         Set the HTTP port (overridden by --port)
 `;
 
+// src/config/data-dir.ts
+import path5 from "path";
+function resolveDataDir(env, homeDir) {
+  const override = env.CHAT_LOGBOOK_DATA_DIR?.trim();
+  if (override) {
+    return path5.resolve(override);
+  }
+  return path5.join(homeDir, ".chat-logbook");
+}
+
+// src/list-counts.ts
+import fs7 from "fs";
+import path6 from "path";
+import Database3 from "better-sqlite3";
+var ARCHIVE_DB2 = "archive.db";
+var METADATA_DB2 = "metadata.db";
+function createChatCountsQuery({
+  dataDir: dataDir2
+}) {
+  const archive2 = new Database3(path6.join(dataDir2, ARCHIVE_DB2), {
+    readonly: true
+  });
+  const metadataPath = path6.join(dataDir2, METADATA_DB2);
+  const hasMetadata = fs7.existsSync(metadataPath);
+  if (hasMetadata) {
+    archive2.prepare("ATTACH DATABASE ? AS meta").run(metadataPath);
+  }
+  function queryCounts({
+    includeTrashed = false
+  }) {
+    const viewClause = viewPredicate(includeTrashed, hasMetadata);
+    const total = archive2.prepare(`SELECT count(*) AS n FROM chats c ${viewClause}`).get().n;
+    const projects = archive2.prepare(
+      `SELECT coalesce(c.project, '') AS project,
+                count(*) AS count,
+                max(c.updated_at) AS lastActiveAt
+         FROM chats c ${viewClause}
+         GROUP BY coalesce(c.project, '')`
+    ).all();
+    const tags3 = hasMetadata ? archive2.prepare(
+      `SELECT ct.tag_id AS tagId, count(*) AS count
+             FROM meta.chat_tags ct
+             JOIN chats c ON c.id = ct.chat_id
+             ${viewClause}
+             GROUP BY ct.tag_id`
+    ).all() : [];
+    const untagged = hasMetadata ? archive2.prepare(
+      `SELECT count(*) AS n
+               FROM chats c ${viewClause}
+               AND c.id NOT IN (SELECT chat_id FROM meta.chat_tags)`
+    ).get().n : total;
+    return { total, projects, tags: tags3, untagged };
+  }
+  function queryFilteredTotal({
+    includeTrashed = false,
+    projects,
+    tags: tags3
+  }) {
+    const clauses = [];
+    const params = [];
+    if (hasMetadata) {
+      clauses.push(
+        includeTrashed ? "c.id IN (SELECT id FROM meta.chats_meta WHERE is_deleted = 1)" : "c.id NOT IN (SELECT id FROM meta.chats_meta WHERE is_deleted = 1)"
+      );
+    } else if (includeTrashed) {
+      return 0;
+    }
+    const filter = buildFilterClauses({ projects, tags: tags3, hasMetadata });
+    clauses.push(...filter.clauses);
+    params.push(...filter.params);
+    const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+    return archive2.prepare(`SELECT count(*) AS n FROM chats c ${where}`).get(...params).n;
+  }
+  return {
+    queryCounts,
+    queryFilteredTotal,
+    close() {
+      archive2.close();
+    }
+  };
+}
+function viewPredicate(includeTrashed, hasMetadata) {
+  if (!hasMetadata) {
+    return includeTrashed ? "WHERE 0" : "";
+  }
+  return includeTrashed ? "WHERE c.id IN (SELECT id FROM meta.chats_meta WHERE is_deleted = 1)" : "WHERE c.id NOT IN (SELECT id FROM meta.chats_meta WHERE is_deleted = 1)";
+}
+
+// src/list-events.ts
+function createListEventHub() {
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    publish(event) {
+      for (const listener of listeners) listener(event);
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+
+// src/metadata/reconcile-title-sort-keys.ts
+function reconcileTitleSortKeys({
+  archive: archive2,
+  metadata: metadata2
+}) {
+  const key = (agent, sourceId) => [agent, sourceId].join("\0");
+  const firstTextByKey = new Map(
+    archive2.read.listFirstUserTexts().map((r) => [key(r.agent, r.sourceId), r.text])
+  );
+  for (const row of archive2.read.listChatRows()) {
+    const baseTitle = deriveBaseTitle(
+      firstTextByKey.get(key(row.agent, row.sourceId))
+    );
+    metadata2.setTitleTextKey(row.id, computeSortKey(baseTitle));
+  }
+}
+
 // src/index.ts
-var __dirname = path4.dirname(fileURLToPath2(import.meta.url));
-var pkgPath = path4.join(__dirname, "../../package.json");
-var pkg = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
+var __dirname = path7.dirname(fileURLToPath2(import.meta.url));
+var pkgPath = path7.join(__dirname, "../../package.json");
+var pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf-8"));
 var action = parseCliArgs(process.argv.slice(2), {
   PORT: process.env.PORT
 });
@@ -11449,27 +12130,58 @@ if (action.kind === "error") {
   process.exit(1);
 }
 updateNotifier({ pkg }).notify({ defer: false, isGlobal: true });
-var dataDir = path4.join(os.homedir(), ".chat-logbook");
-var webDistDir = path4.join(__dirname, "../../web/dist");
+var dataDir = resolveDataDir(
+  { CHAT_LOGBOOK_DATA_DIR: process.env.CHAT_LOGBOOK_DATA_DIR },
+  os.homedir()
+);
+var webDistDir = path7.join(__dirname, "../../web/dist");
 var port = action.port;
 var archive = createArchiveRepository({ dataDir });
 var checkpoint = createCheckpointRepository({ dataDir });
 var metadata = createMetadataRepository({ dataDir });
 var tags2 = createTagRepository({ dataDir });
-var app = createApp({ archive, metadata, tags: tags2, webDistDir });
+var pageQuery = createChatPageQuery({ dataDir });
+var countsQuery = createChatCountsQuery({ dataDir });
+var listEvents = createListEventHub();
+var app = createApp({
+  archive,
+  metadata,
+  tags: tags2,
+  pageQuery,
+  countsQuery,
+  listEvents,
+  webDistDir
+});
 var initialIngest = startIngestionInBackground({
   plugins,
   archive,
   checkpoint,
   env: { homeDir: os.homedir() }
 });
+function reconcileTitles() {
+  try {
+    reconcileTitleSortKeys({ archive, metadata });
+  } catch (err) {
+    console.error("[title-sort-key] reconcile failed:", err);
+  }
+}
 var watcher = startWatcher({
   plugins,
   archive,
   checkpoint,
-  env: { homeDir: os.homedir() }
+  env: { homeDir: os.homedir() },
+  // Each watcher-driven ingest can add a chat or change a first user message;
+  // refresh the Title keys so the Title axis stays current, then push a
+  // `changed` event so connected clients reconcile their loaded window (#132).
+  onIngest: () => {
+    reconcileTitles();
+    listEvents.publish({ type: "changed" });
+  }
 });
-void initialIngest.done.then(() => watcher.ready).catch(() => {
+void initialIngest.done.then(() => {
+  reconcileTitles();
+  return watcher.ready;
+}).catch(() => {
 });
 function shutdown() {
   void watcher.close().finally(() => process.exit(0));