chat-logbook 0.4.0 → 0.4.1

package/api/dist/index.js

@@ -1,9 +1,15 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
 // src/index.ts
-import fs4 from "fs";
+import fs6 from "fs";
 import os from "os";
-import path3 from "path";
+import path4 from "path";
 import { exec } from "child_process";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath as fileURLToPath3 } from "url";
 
 // ../node_modules/.pnpm/@hono+node-server@1.19.11_hono@4.12.9/node_modules/@hono/node-server/dist/index.mjs
 import { createServer as createServerHTTP } from "http";
@@ -699,26 +705,26 @@ var handleParsingNestedValues = (form, key, value) => {
 };
 
 // ../node_modules/.pnpm/hono@4.12.9/node_modules/hono/dist/utils/url.js
-var splitPath = (path4) => {
-  const paths = path4.split("/");
+var splitPath = (path5) => {
+  const paths = path5.split("/");
   if (paths[0] === "") {
     paths.shift();
   }
   return paths;
 };
 var splitRoutingPath = (routePath) => {
-  const { groups, path: path4 } = extractGroupsFromPath(routePath);
-  const paths = splitPath(path4);
+  const { groups, path: path5 } = extractGroupsFromPath(routePath);
+  const paths = splitPath(path5);
   return replaceGroupMarks(paths, groups);
 };
-var extractGroupsFromPath = (path4) => {
+var extractGroupsFromPath = (path5) => {
   const groups = [];
-  path4 = path4.replace(/\{[^}]+\}/g, (match2, index) => {
+  path5 = path5.replace(/\{[^}]+\}/g, (match2, index) => {
     const mark = `@${index}`;
     groups.push([mark, match2]);
     return mark;
   });
-  return { groups, path: path4 };
+  return { groups, path: path5 };
 };
 var replaceGroupMarks = (paths, groups) => {
   for (let i = groups.length - 1; i >= 0; i--) {
@@ -775,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 path4 = url.slice(start, end);
-      return tryDecodeURI(path4.includes("%25") ? path4.replace(/%25/g, "%2525") : path4);
+      const path5 = url.slice(start, end);
+      return tryDecodeURI(path5.includes("%25") ? path5.replace(/%25/g, "%2525") : path5);
     } else if (charCode === 63 || charCode === 35) {
       break;
     }
@@ -793,11 +799,11 @@ var mergePath = (base, sub, ...rest) => {
   }
   return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
 };
-var checkOptionalParameter = (path4) => {
-  if (path4.charCodeAt(path4.length - 1) !== 63 || !path4.includes(":")) {
+var checkOptionalParameter = (path5) => {
+  if (path5.charCodeAt(path5.length - 1) !== 63 || !path5.includes(":")) {
     return null;
   }
-  const segments = path4.split("/");
+  const segments = path5.split("/");
   const results = [];
   let basePath = "";
   segments.forEach((segment) => {
@@ -938,9 +944,9 @@ var HonoRequest = class {
    */
   path;
   bodyCache = {};
-  constructor(request, path4 = "/", matchResult = [[]]) {
+  constructor(request, path5 = "/", matchResult = [[]]) {
     this.raw = request;
-    this.path = path4;
+    this.path = path5;
     this.#matchResult = matchResult;
     this.#validatedData = {};
   }
@@ -1677,8 +1683,8 @@ var Hono = class _Hono {
         return this;
       };
     });
-    this.on = (method, path4, ...handlers) => {
-      for (const p of [path4].flat()) {
+    this.on = (method, path5, ...handlers) => {
+      for (const p of [path5].flat()) {
         this.#path = p;
         for (const m of [method].flat()) {
           handlers.map((handler) => {
@@ -1735,8 +1741,8 @@ var Hono = class _Hono {
    * app.route("/api", app2) // GET /api/user
    * ```
    */
-  route(path4, app2) {
-    const subApp = this.basePath(path4);
+  route(path5, app2) {
+    const subApp = this.basePath(path5);
     app2.routes.map((r) => {
       let handler;
       if (app2.errorHandler === errorHandler) {
@@ -1762,9 +1768,9 @@ var Hono = class _Hono {
    * const api = new Hono().basePath('/api')
    * ```
    */
-  basePath(path4) {
+  basePath(path5) {
     const subApp = this.#clone();
-    subApp._basePath = mergePath(this._basePath, path4);
+    subApp._basePath = mergePath(this._basePath, path5);
     return subApp;
   }
   /**
@@ -1838,7 +1844,7 @@ var Hono = class _Hono {
    * })
    * ```
    */
-  mount(path4, applicationHandler, options) {
+  mount(path5, applicationHandler, options) {
     let replaceRequest;
     let optionHandler;
     if (options) {
@@ -1865,7 +1871,7 @@ var Hono = class _Hono {
       return [c.env, executionContext];
     };
     replaceRequest ||= (() => {
-      const mergedPath = mergePath(this._basePath, path4);
+      const mergedPath = mergePath(this._basePath, path5);
       const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
       return (request) => {
         const url = new URL(request.url);
@@ -1880,14 +1886,14 @@ var Hono = class _Hono {
       }
       await next();
     };
-    this.#addRoute(METHOD_NAME_ALL, mergePath(path4, "*"), handler);
+    this.#addRoute(METHOD_NAME_ALL, mergePath(path5, "*"), handler);
     return this;
   }
-  #addRoute(method, path4, handler) {
+  #addRoute(method, path5, handler) {
     method = method.toUpperCase();
-    path4 = mergePath(this._basePath, path4);
-    const r = { basePath: this._basePath, path: path4, method, handler };
-    this.router.add(method, path4, [handler, r]);
+    path5 = mergePath(this._basePath, path5);
+    const r = { basePath: this._basePath, path: path5, method, handler };
+    this.router.add(method, path5, [handler, r]);
     this.routes.push(r);
   }
   #handleError(err, c) {
@@ -1900,10 +1906,10 @@ var Hono = class _Hono {
     if (method === "HEAD") {
       return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
     }
-    const path4 = this.getPath(request, { env });
-    const matchResult = this.router.match(method, path4);
+    const path5 = this.getPath(request, { env });
+    const matchResult = this.router.match(method, path5);
     const c = new Context(request, {
-      path: path4,
+      path: path5,
       matchResult,
       env,
       executionCtx,
@@ -2003,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, path4) {
+function match(method, path5) {
   const matchers = this.buildAllMatchers();
   const match2 = ((method2, path22) => {
     const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
@@ -2019,7 +2025,7 @@ function match(method, path4) {
     return [matcher[1][index], match3];
   });
   this.match = match2;
-  return match2(method, path4);
+  return match2(method, path5);
 }
 
 // ../node_modules/.pnpm/hono@4.12.9/node_modules/hono/dist/router/reg-exp-router/node.js
@@ -2134,12 +2140,12 @@ var Node = class _Node {
 var Trie = class {
   #context = { varIndex: 0 };
   #root = new Node();
-  insert(path4, index, pathErrorCheckOnly) {
+  insert(path5, index, pathErrorCheckOnly) {
     const paramAssoc = [];
     const groups = [];
     for (let i = 0; ; ) {
       let replaced = false;
-      path4 = path4.replace(/\{[^}]+\}/g, (m) => {
+      path5 = path5.replace(/\{[^}]+\}/g, (m) => {
         const mark = `@\\${i}`;
         groups[i] = [mark, m];
         i++;
@@ -2150,7 +2156,7 @@ var Trie = class {
         break;
       }
     }
-    const tokens = path4.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+    const tokens = path5.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
     for (let i = groups.length - 1; i >= 0; i--) {
       const [mark] = groups[i];
       for (let j = tokens.length - 1; j >= 0; j--) {
@@ -2189,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(path4) {
-  return wildcardRegExpCache[path4] ??= new RegExp(
-    path4 === "*" ? "" : `^${path4.replace(
+function buildWildcardRegExp(path5) {
+  return wildcardRegExpCache[path5] ??= new RegExp(
+    path5 === "*" ? "" : `^${path5.replace(
       /\/\*$|([.\\+*[^\]$()])/g,
       (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)"
     )}$`
@@ -2213,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, path4, handlers] = routesWithStaticPathFlag[i];
+    const [pathErrorCheckOnly, path5, handlers] = routesWithStaticPathFlag[i];
     if (pathErrorCheckOnly) {
-      staticMap[path4] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
+      staticMap[path5] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
     } else {
       j++;
     }
     let paramAssoc;
     try {
-      paramAssoc = trie.insert(path4, j, pathErrorCheckOnly);
+      paramAssoc = trie.insert(path5, j, pathErrorCheckOnly);
     } catch (e) {
-      throw e === PATH_ERROR ? new UnsupportedPathError(path4) : e;
+      throw e === PATH_ERROR ? new UnsupportedPathError(path5) : e;
     }
     if (pathErrorCheckOnly) {
       continue;
@@ -2257,12 +2263,12 @@ function buildMatcherFromPreprocessedRoutes(routes) {
   }
   return [regexp, handlerMap, staticMap];
 }
-function findMiddleware(middleware, path4) {
+function findMiddleware(middleware, path5) {
   if (!middleware) {
     return void 0;
   }
   for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
-    if (buildWildcardRegExp(k).test(path4)) {
+    if (buildWildcardRegExp(k).test(path5)) {
       return [...middleware[k]];
     }
   }
@@ -2276,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, path4, handler) {
+  add(method, path5, handler) {
     const middleware = this.#middleware;
     const routes = this.#routes;
     if (!middleware || !routes) {
@@ -2291,18 +2297,18 @@ var RegExpRouter = class {
         });
       });
     }
-    if (path4 === "/*") {
-      path4 = "*";
+    if (path5 === "/*") {
+      path5 = "*";
     }
-    const paramCount = (path4.match(/\/:/g) || []).length;
-    if (/\*$/.test(path4)) {
-      const re = buildWildcardRegExp(path4);
+    const paramCount = (path5.match(/\/:/g) || []).length;
+    if (/\*$/.test(path5)) {
+      const re = buildWildcardRegExp(path5);
       if (method === METHOD_NAME_ALL) {
         Object.keys(middleware).forEach((m) => {
-          middleware[m][path4] ||= findMiddleware(middleware[m], path4) || findMiddleware(middleware[METHOD_NAME_ALL], path4) || [];
+          middleware[m][path5] ||= findMiddleware(middleware[m], path5) || findMiddleware(middleware[METHOD_NAME_ALL], path5) || [];
         });
       } else {
-        middleware[method][path4] ||= findMiddleware(middleware[method], path4) || findMiddleware(middleware[METHOD_NAME_ALL], path4) || [];
+        middleware[method][path5] ||= findMiddleware(middleware[method], path5) || findMiddleware(middleware[METHOD_NAME_ALL], path5) || [];
       }
       Object.keys(middleware).forEach((m) => {
         if (method === METHOD_NAME_ALL || method === m) {
@@ -2320,7 +2326,7 @@ var RegExpRouter = class {
       });
       return;
     }
-    const paths = checkOptionalParameter(path4) || [path4];
+    const paths = checkOptionalParameter(path5) || [path5];
     for (let i = 0, len = paths.length; i < len; i++) {
       const path22 = paths[i];
       Object.keys(routes).forEach((m) => {
@@ -2347,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((path4) => [path4, r[method][path4]]) : [];
+      const ownRoute = r[method] ? Object.keys(r[method]).map((path5) => [path5, r[method][path5]]) : [];
       if (ownRoute.length !== 0) {
         hasOwnRoute ||= true;
         routes.push(...ownRoute);
       } else if (method !== METHOD_NAME_ALL) {
         routes.push(
-          ...Object.keys(r[METHOD_NAME_ALL]).map((path4) => [path4, r[METHOD_NAME_ALL][path4]])
+          ...Object.keys(r[METHOD_NAME_ALL]).map((path5) => [path5, r[METHOD_NAME_ALL][path5]])
         );
       }
     });
@@ -2373,13 +2379,13 @@ var SmartRouter = class {
   constructor(init) {
     this.#routers = init.routers;
   }
-  add(method, path4, handler) {
+  add(method, path5, handler) {
     if (!this.#routes) {
       throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
-    this.#routes.push([method, path4, handler]);
+    this.#routes.push([method, path5, handler]);
   }
-  match(method, path4) {
+  match(method, path5) {
     if (!this.#routes) {
       throw new Error("Fatal error");
     }
@@ -2394,7 +2400,7 @@ var SmartRouter = class {
         for (let i2 = 0, len2 = routes.length; i2 < len2; i2++) {
           router.add(...routes[i2]);
         }
-        res = router.match(method, path4);
+        res = router.match(method, path5);
       } catch (e) {
         if (e instanceof UnsupportedPathError) {
           continue;
@@ -2444,10 +2450,10 @@ var Node2 = class _Node2 {
     }
     this.#patterns = [];
   }
-  insert(method, path4, handler) {
+  insert(method, path5, handler) {
     this.#order = ++this.#order;
     let curNode = this;
-    const parts = splitRoutingPath(path4);
+    const parts = splitRoutingPath(path5);
     const possibleKeys = [];
     for (let i = 0, len = parts.length; i < len; i++) {
       const p = parts[i];
@@ -2496,12 +2502,12 @@ var Node2 = class _Node2 {
       }
     }
   }
-  search(method, path4) {
+  search(method, path5) {
     const handlerSets = [];
     this.#params = emptyParams;
     const curNode = this;
     let curNodes = [curNode];
-    const parts = splitPath(path4);
+    const parts = splitPath(path5);
     const curNodesQueue = [];
     const len = parts.length;
     let partOffsets = null;
@@ -2543,13 +2549,13 @@ var Node2 = class _Node2 {
           if (matcher instanceof RegExp) {
             if (partOffsets === null) {
               partOffsets = new Array(len);
-              let offset = path4[0] === "/" ? 1 : 0;
+              let offset = path5[0] === "/" ? 1 : 0;
               for (let p = 0; p < len; p++) {
                 partOffsets[p] = offset;
                 offset += parts[p].length + 1;
               }
             }
-            const restPathString = path4.substring(partOffsets[i]);
+            const restPathString = path5.substring(partOffsets[i]);
             const m = matcher.exec(restPathString);
             if (m) {
               params[name] = m[0];
@@ -2602,18 +2608,18 @@ var TrieRouter = class {
   constructor() {
     this.#node = new Node2();
   }
-  add(method, path4, handler) {
-    const results = checkOptionalParameter(path4);
+  add(method, path5, handler) {
+    const results = checkOptionalParameter(path5);
     if (results) {
       for (let i = 0, len = results.length; i < len; i++) {
         this.#node.insert(method, results[i], handler);
       }
       return;
     }
-    this.#node.insert(method, path4, handler);
+    this.#node.insert(method, path5, handler);
   }
-  match(method, path4) {
-    return this.#node.search(method, path4);
+  match(method, path5) {
+    return this.#node.search(method, path5);
   }
 };
 
@@ -2744,10 +2750,10 @@ var createStreamBody = (stream) => {
   });
   return body;
 };
-var getStats = (path4) => {
+var getStats = (path5) => {
   let stats;
   try {
-    stats = statSync(path4);
+    stats = statSync(path5);
   } catch {
   }
   return stats;
@@ -2790,21 +2796,21 @@ var serveStatic = (options = { root: "" }) => {
         return next();
       }
     }
-    let path4 = join(
+    let path5 = join(
       root,
       !optionPath && options.rewriteRequestPath ? options.rewriteRequestPath(filename, c) : filename
     );
-    let stats = getStats(path4);
+    let stats = getStats(path5);
     if (stats && stats.isDirectory()) {
       const indexFile = options.index ?? "index.html";
-      path4 = join(path4, indexFile);
-      stats = getStats(path4);
+      path5 = join(path5, indexFile);
+      stats = getStats(path5);
     }
     if (!stats) {
-      await options.onNotFound?.(path4, c);
+      await options.onNotFound?.(path5, c);
       return next();
     }
-    const mimeType = getMimeType(path4);
+    const mimeType = getMimeType(path5);
     c.header("Content-Type", mimeType || "application/octet-stream");
     if (options.precompressed && (!mimeType || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
       const acceptEncodingSet = new Set(
@@ -2814,12 +2820,12 @@ var serveStatic = (options = { root: "" }) => {
         if (!acceptEncodingSet.has(encoding)) {
           continue;
         }
-        const precompressedStats = getStats(path4 + ENCODINGS[encoding]);
+        const precompressedStats = getStats(path5 + ENCODINGS[encoding]);
         if (precompressedStats) {
           c.header("Content-Encoding", encoding);
           c.header("Vary", "Accept-Encoding", { append: true });
           stats = precompressedStats;
-          path4 = path4 + ENCODINGS[encoding];
+          path5 = path5 + ENCODINGS[encoding];
           break;
         }
       }
@@ -2833,7 +2839,7 @@ var serveStatic = (options = { root: "" }) => {
       result = c.body(null);
     } else if (!range) {
       c.header("Content-Length", size.toString());
-      result = c.body(createStreamBody(createReadStream(path4)), 200);
+      result = c.body(createStreamBody(createReadStream(path5)), 200);
     } else {
       c.header("Accept-Ranges", "bytes");
       c.header("Date", stats.birthtime.toUTCString());
@@ -2844,22 +2850,16 @@ var serveStatic = (options = { root: "" }) => {
         end = size - 1;
       }
       const chunksize = end - start + 1;
-      const stream = createReadStream(path4, { start, end });
+      const stream = createReadStream(path5, { start, end });
       c.header("Content-Length", chunksize.toString());
       c.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
       result = c.body(createStreamBody(stream), 206);
     }
-    await options.onFound?.(path4, c);
+    await options.onFound?.(path5, c);
     return result;
   };
 };
 
-// src/metadata/repository.ts
-import fs2 from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-import Database 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/entity.js
 var entityKind = /* @__PURE__ */ Symbol.for("drizzle:entityKind");
 function is(value, type) {
@@ -4173,7 +4173,7 @@ var QueryPromise = class {
 function mapResultRow(columns, row, joinsNotNullableMap) {
   const nullifyMap = {};
   const result = columns.reduce(
-    (result2, { path: path4, field }, columnIndex) => {
+    (result2, { path: path5, field }, columnIndex) => {
       let decoder;
       if (is(field, Column)) {
         decoder = field;
@@ -4185,8 +4185,8 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
         decoder = field.sql.decoder;
       }
       let node = result2;
-      for (const [pathChunkIndex, pathChunk] of path4.entries()) {
-        if (pathChunkIndex < path4.length - 1) {
+      for (const [pathChunkIndex, pathChunk] of path5.entries()) {
+        if (pathChunkIndex < path5.length - 1) {
           if (!(pathChunk in node)) {
             node[pathChunk] = {};
           }
@@ -4194,8 +4194,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) && path4.length === 2) {
-            const objectName = path4[0];
+          if (joinsNotNullableMap && is(field, Column) && path5.length === 2) {
+            const objectName = path5[0];
             if (!(objectName in nullifyMap)) {
               nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
             } else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== getTableName(field.table)) {
@@ -4754,76 +4754,17 @@ function mapRelationalRow(tablesConfig, tableConfig, row, buildQueryResultSelect
   return result;
 }
 
-// ../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";
-
-// ../node_modules/.pnpm/drizzle-orm@0.45.2_@types+better-sqlite3@7.6.13_better-sqlite3@12.9.0/node_modules/drizzle-orm/selection-proxy.js
-var SelectionProxyHandler = class _SelectionProxyHandler {
-  static [entityKind] = "SelectionProxyHandler";
-  config;
-  constructor(config) {
-    this.config = { ...config };
-  }
-  get(subquery, prop) {
-    if (prop === "_") {
-      return {
-        ...subquery["_"],
-        selectedFields: new Proxy(
-          subquery._.selectedFields,
-          this
-        )
-      };
-    }
-    if (prop === ViewBaseConfig) {
-      return {
-        ...subquery[ViewBaseConfig],
-        selectedFields: new Proxy(
-          subquery[ViewBaseConfig].selectedFields,
-          this
-        )
-      };
-    }
-    if (typeof prop === "symbol") {
-      return subquery[prop];
-    }
-    const columns = is(subquery, Subquery) ? subquery._.selectedFields : is(subquery, View) ? subquery[ViewBaseConfig].selectedFields : subquery;
-    const value = columns[prop];
-    if (is(value, SQL.Aliased)) {
-      if (this.config.sqlAliasedBehavior === "sql" && !value.isSelectionField) {
-        return value.sql;
-      }
-      const newValue = value.clone();
-      newValue.isSelectionField = true;
-      return newValue;
-    }
-    if (is(value, SQL)) {
-      if (this.config.sqlBehavior === "sql") {
-        return value;
-      }
-      throw new Error(
-        `You tried to reference "${prop}" field from a subquery, which is a raw SQL field, but it doesn't have an alias declared. Please add an alias to the field using ".as('alias')" method.`
-      );
-    }
-    if (is(value, Column)) {
-      if (this.config.alias) {
-        return new Proxy(
-          value,
-          new ColumnAliasProxyHandler(
-            new Proxy(
-              value.table,
-              new TableAliasProxyHandler(this.config.alias, this.config.replaceOriginalName ?? false)
-            )
-          )
-        );
-      }
-      return value;
-    }
-    if (typeof value !== "object" || value === null) {
-      return value;
-    }
-    return new Proxy(value, new _SelectionProxyHandler(this.config));
-  }
-};
+// src/archive/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  archiveMeta: () => archiveMeta,
+  ingestionEvents: () => ingestionEvents,
+  messages: () => messages,
+  rawMessages: () => rawMessages,
+  schemaVersion: () => schemaVersion,
+  sessionScanState: () => sessionScanState,
+  sessions: () => sessions
+});
 
 // ../node_modules/.pnpm/drizzle-orm@0.45.2_@types+better-sqlite3@7.6.13_better-sqlite3@12.9.0/node_modules/drizzle-orm/sqlite-core/foreign-keys.js
 var ForeignKeyBuilder2 = class {
@@ -5377,6 +5318,74 @@ function text(a, b = {}) {
   return new SQLiteTextBuilder(name, config);
 }
 
+// ../node_modules/.pnpm/drizzle-orm@0.45.2_@types+better-sqlite3@7.6.13_better-sqlite3@12.9.0/node_modules/drizzle-orm/selection-proxy.js
+var SelectionProxyHandler = class _SelectionProxyHandler {
+  static [entityKind] = "SelectionProxyHandler";
+  config;
+  constructor(config) {
+    this.config = { ...config };
+  }
+  get(subquery, prop) {
+    if (prop === "_") {
+      return {
+        ...subquery["_"],
+        selectedFields: new Proxy(
+          subquery._.selectedFields,
+          this
+        )
+      };
+    }
+    if (prop === ViewBaseConfig) {
+      return {
+        ...subquery[ViewBaseConfig],
+        selectedFields: new Proxy(
+          subquery[ViewBaseConfig].selectedFields,
+          this
+        )
+      };
+    }
+    if (typeof prop === "symbol") {
+      return subquery[prop];
+    }
+    const columns = is(subquery, Subquery) ? subquery._.selectedFields : is(subquery, View) ? subquery[ViewBaseConfig].selectedFields : subquery;
+    const value = columns[prop];
+    if (is(value, SQL.Aliased)) {
+      if (this.config.sqlAliasedBehavior === "sql" && !value.isSelectionField) {
+        return value.sql;
+      }
+      const newValue = value.clone();
+      newValue.isSelectionField = true;
+      return newValue;
+    }
+    if (is(value, SQL)) {
+      if (this.config.sqlBehavior === "sql") {
+        return value;
+      }
+      throw new Error(
+        `You tried to reference "${prop}" field from a subquery, which is a raw SQL field, but it doesn't have an alias declared. Please add an alias to the field using ".as('alias')" method.`
+      );
+    }
+    if (is(value, Column)) {
+      if (this.config.alias) {
+        return new Proxy(
+          value,
+          new ColumnAliasProxyHandler(
+            new Proxy(
+              value.table,
+              new TableAliasProxyHandler(this.config.alias, this.config.replaceOriginalName ?? false)
+            )
+          )
+        );
+      }
+      return value;
+    }
+    if (typeof value !== "object" || value === null) {
+      return value;
+    }
+    return new Proxy(value, new _SelectionProxyHandler(this.config));
+  }
+};
+
 // ../node_modules/.pnpm/drizzle-orm@0.45.2_@types+better-sqlite3@7.6.13_better-sqlite3@12.9.0/node_modules/drizzle-orm/sqlite-core/columns/all.js
 function getSQLiteColumnBuilders() {
   return {
@@ -5428,6 +5437,52 @@ var sqliteTable = (name, columns, extraConfig) => {
   return sqliteTableBase(name, columns, extraConfig);
 };
 
+// ../node_modules/.pnpm/drizzle-orm@0.45.2_@types+better-sqlite3@7.6.13_better-sqlite3@12.9.0/node_modules/drizzle-orm/sqlite-core/indexes.js
+var IndexBuilderOn = class {
+  constructor(name, unique) {
+    this.name = name;
+    this.unique = unique;
+  }
+  static [entityKind] = "SQLiteIndexBuilderOn";
+  on(...columns) {
+    return new IndexBuilder(this.name, columns, this.unique);
+  }
+};
+var IndexBuilder = class {
+  static [entityKind] = "SQLiteIndexBuilder";
+  /** @internal */
+  config;
+  constructor(name, columns, unique) {
+    this.config = {
+      name,
+      columns,
+      unique,
+      where: void 0
+    };
+  }
+  /**
+   * Condition for partial index.
+   */
+  where(condition) {
+    this.config.where = condition;
+    return this;
+  }
+  /** @internal */
+  build(table) {
+    return new Index(this.config, table);
+  }
+};
+var Index = class {
+  static [entityKind] = "SQLiteIndex";
+  config;
+  constructor(config, table) {
+    this.config = { ...config, table };
+  }
+};
+function uniqueIndex(name) {
+  return new IndexBuilderOn(name, true);
+}
+
 // ../node_modules/.pnpm/drizzle-orm@0.45.2_@types+better-sqlite3@7.6.13_better-sqlite3@12.9.0/node_modules/drizzle-orm/sqlite-core/utils.js
 function extractUsedTable(table) {
   if (is(table, SQLiteTable)) {
@@ -8114,6 +8169,219 @@ var SQLiteTransaction = class extends BaseSQLiteDatabase {
   }
 };
 
+// src/archive/schema.ts
+var archiveMeta = sqliteTable("archive_meta", {
+  id: integer("id").primaryKey(),
+  archiveUuid: text("archive_uuid").notNull(),
+  createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull()
+});
+var schemaVersion = sqliteTable("schema_version", {
+  version: integer("version").primaryKey(),
+  appliedAt: integer("applied_at", { mode: "timestamp_ms" }).notNull()
+});
+var sessions = sqliteTable(
+  "sessions",
+  {
+    id: text("id").primaryKey(),
+    shortCode: text("short_code").notNull().unique(),
+    agent: text("agent").notNull(),
+    sourceSessionId: text("source_session_id").notNull(),
+    firstSeenAt: integer("first_seen_at", { mode: "timestamp_ms" }).notNull(),
+    project: text("project")
+  },
+  (t) => [
+    uniqueIndex("sessions_agent_source_idx").on(t.agent, t.sourceSessionId)
+  ]
+);
+var rawMessages = sqliteTable(
+  "raw_messages",
+  {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    agent: text("agent").notNull(),
+    sessionId: text("session_id").notNull(),
+    sourcePath: text("source_path").notNull(),
+    sourceLocator: text("source_locator").notNull(),
+    rawPayload: text("raw_payload").notNull(),
+    payloadHash: text("payload_hash").notNull(),
+    ingestedAt: integer("ingested_at", { mode: "timestamp_ms" }).notNull()
+  },
+  (t) => [
+    uniqueIndex("raw_messages_idem_idx").on(
+      t.agent,
+      t.sessionId,
+      t.payloadHash
+    )
+  ]
+);
+var messages = sqliteTable(
+  "messages",
+  {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    agent: text("agent").notNull(),
+    sessionId: text("session_id").notNull(),
+    messageId: text("message_id").notNull(),
+    role: text("role").notNull(),
+    ts: integer("ts", { mode: "timestamp_ms" }).notNull(),
+    text: text("text").notNull(),
+    blocks: text("blocks", { mode: "json" }).notNull(),
+    rawId: integer("raw_id").notNull().references(() => rawMessages.id)
+  },
+  (t) => [
+    uniqueIndex("messages_canonical_idx").on(t.agent, t.sessionId, t.messageId)
+  ]
+);
+var sessionScanState = sqliteTable(
+  "session_scan_state",
+  {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    agent: text("agent").notNull(),
+    sessionId: text("session_id").notNull(),
+    sourcePath: text("source_path").notNull(),
+    lastMtimeMs: integer("last_mtime_ms").notNull(),
+    lastSizeBytes: integer("last_size_bytes").notNull(),
+    lastScannedAt: integer("last_scanned_at", {
+      mode: "timestamp_ms"
+    }).notNull()
+  },
+  (t) => [uniqueIndex("session_scan_state_idx").on(t.agent, t.sessionId)]
+);
+var ingestionEvents = sqliteTable("ingestion_events", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  agent: text("agent").notNull(),
+  sessionId: text("session_id").notNull(),
+  sourcePath: text("source_path").notNull(),
+  eventType: text("event_type").notNull(),
+  detail: text("detail", { mode: "json" }).notNull(),
+  observedAt: integer("observed_at", { mode: "timestamp_ms" }).notNull()
+});
+
+// src/visibility.ts
+function loadSessionVisibility(metadata2, opts) {
+  const trashed = new Set(metadata2.listDeletedIds());
+  const showTrashed = opts.includeTrashed === true;
+  return {
+    isTrashed: (internalId) => trashed.has(internalId),
+    isVisible: (internalId) => showTrashed || !trashed.has(internalId)
+  };
+}
+
+// src/app.ts
+function toApiBlock(block) {
+  if (block.type === "tool_result") {
+    return {
+      type: "tool_result",
+      tool_use_id: String(block.toolUseId ?? ""),
+      content: block.content
+    };
+  }
+  return block;
+}
+var CLAUDE_CODE_AGENT = "claude-code";
+function createApp({ archive: archive2, metadata: metadata2, webDistDir: webDistDir2 }) {
+  const app2 = new Hono2();
+  function findArchiveSessionBySourceId(sourceSessionId) {
+    return archive2.db.select().from(sessions).where(eq(sessions.sourceSessionId, sourceSessionId)).get();
+  }
+  app2.get("/api/sessions", (c) => {
+    const visibility = loadSessionVisibility(metadata2, {
+      includeTrashed: c.req.query("includeTrashed") === "true"
+    });
+    const rows = archive2.db.select().from(sessions).all();
+    const sessions2 = [];
+    for (const row of rows) {
+      if (!visibility.isVisible(row.id)) continue;
+      const isDeleted = visibility.isTrashed(row.id);
+      const lastMessage = archive2.db.select({ ts: messages.ts }).from(messages).where(
+        and(
+          eq(messages.agent, CLAUDE_CODE_AGENT),
+          eq(messages.sessionId, row.sourceSessionId)
+        )
+      ).orderBy(desc(messages.ts)).limit(1).get();
+      const session = {
+        id: row.sourceSessionId,
+        title: deriveTitle(archive2, metadata2, row),
+        project: row.project ?? "",
+        createdAt: row.firstSeenAt.getTime(),
+        updatedAt: lastMessage ? lastMessage.ts.getTime() : row.firstSeenAt.getTime()
+      };
+      if (isDeleted) session.isDeleted = true;
+      sessions2.push(session);
+    }
+    return c.json({ sessions: sessions2 });
+  });
+  app2.delete("/api/sessions/:id", (c) => {
+    const sessionId = c.req.param("id");
+    const row = findArchiveSessionBySourceId(sessionId);
+    if (!row) {
+      return c.json({ error: "Session not found" }, 404);
+    }
+    metadata2.softDelete(row.id);
+    return c.body(null, 204);
+  });
+  app2.post("/api/sessions/:id/restore", (c) => {
+    const sessionId = c.req.param("id");
+    const row = findArchiveSessionBySourceId(sessionId);
+    if (!row) {
+      return c.json({ error: "Session not found" }, 404);
+    }
+    metadata2.restore(row.id);
+    return c.body(null, 204);
+  });
+  app2.get("/api/sessions/:id", (c) => {
+    const sessionId = c.req.param("id");
+    const row = findArchiveSessionBySourceId(sessionId);
+    if (!row) {
+      return c.json({ error: "Session not found" }, 404);
+    }
+    const visibility = loadSessionVisibility(metadata2, {
+      includeTrashed: c.req.query("includeTrashed") === "true"
+    });
+    if (!visibility.isVisible(row.id)) {
+      return c.json({ error: "Session not found" }, 404);
+    }
+    const rows = archive2.db.select().from(messages).where(
+      and(
+        eq(messages.agent, CLAUDE_CODE_AGENT),
+        eq(messages.sessionId, sessionId)
+      )
+    ).orderBy(asc(messages.ts)).all();
+    const messages2 = rows.map((m) => ({
+      role: m.role,
+      content: m.blocks.map(toApiBlock),
+      timestamp: m.ts.toISOString()
+    }));
+    return c.json({ messages: messages2 });
+  });
+  function deriveTitle(archive3, metadata3, row) {
+    const custom = metadata3.getCustomTitle(row.id);
+    if (custom && custom.trim()) return custom;
+    const firstUser = archive3.db.select({ text: messages.text }).from(messages).where(
+      and(
+        eq(messages.agent, CLAUDE_CODE_AGENT),
+        eq(messages.sessionId, row.sourceSessionId),
+        eq(messages.role, "user")
+      )
+    ).orderBy(asc(messages.ts)).limit(1).get();
+    const text2 = firstUser?.text?.trim().split("\n")[0]?.trim();
+    return text2 && text2.length > 0 ? text2 : "Untitled";
+  }
+  if (webDistDir2) {
+    app2.use("*", serveStatic({ root: webDistDir2 }));
+    app2.use("*", serveStatic({ root: webDistDir2, path: "index.html" }));
+  }
+  return app2;
+}
+
+// src/archive/repository.ts
+import crypto5 from "crypto";
+import fs2 from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import Database 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";
+
 // ../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/session.js
 var BetterSQLiteSession = class extends SQLiteSession {
   constructor(client, dialect, schema, options = {}) {
@@ -8310,202 +8578,525 @@ function migrate(db, config) {
   db.dialect.migrate(migrations, db.session, config);
 }
 
+// src/archive/short-code.ts
+import crypto4 from "crypto";
+var CROCKFORD_ALPHABET = "0123456789abcdefghjkmnpqrstvwxyz";
+var SHORT_CODE_LENGTH = 6;
+var MAX_RETRIES = 5;
+function generateShortCode({
+  isTaken,
+  randomIndex = () => crypto4.randomInt(CROCKFORD_ALPHABET.length)
+}) {
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    let code = "";
+    for (let i = 0; i < SHORT_CODE_LENGTH; i++) {
+      code += CROCKFORD_ALPHABET[randomIndex()];
+    }
+    if (!isTaken(code)) {
+      return code;
+    }
+  }
+  throw new Error(
+    `Failed to generate unique short_code after ${MAX_RETRIES + 1} attempts`
+  );
+}
+
+// src/archive/repository.ts
+function resolveMigrationsFolder() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path.join(here, "../../drizzle/archive"),
+    path.join(here, "./drizzle/archive")
+  ];
+  const found = candidates.find((p) => fs2.existsSync(p));
+  if (!found) {
+    throw new Error("Could not locate archive drizzle migrations folder");
+  }
+  return found;
+}
+function createArchiveRepository({
+  dataDir: dataDir2
+}) {
+  fs2.mkdirSync(dataDir2, { recursive: true });
+  const sqlite = new Database(path.join(dataDir2, "archive.db"));
+  const db = drizzle(sqlite, { schema: schema_exports });
+  migrate(db, { migrationsFolder: resolveMigrationsFolder() });
+  const drizzleMigrations = sqlite.prepare("SELECT id, created_at FROM __drizzle_migrations ORDER BY id ASC").all();
+  for (const m of drizzleMigrations) {
+    db.insert(schemaVersion).values({ version: m.id, appliedAt: new Date(m.created_at) }).onConflictDoNothing().run();
+  }
+  const existing = db.select().from(archiveMeta).get();
+  if (!existing) {
+    db.insert(archiveMeta).values({
+      id: 1,
+      archiveUuid: crypto5.randomUUID(),
+      createdAt: /* @__PURE__ */ new Date()
+    }).run();
+  }
+  return {
+    db,
+    getArchiveUuid() {
+      const row = db.select().from(archiveMeta).get();
+      if (!row) {
+        throw new Error("archive_meta row missing after initialization");
+      }
+      return row.archiveUuid;
+    },
+    getAppliedMigrations() {
+      return db.select().from(schemaVersion).all().map((r) => ({ version: r.version, appliedAt: r.appliedAt }));
+    },
+    generateShortCode() {
+      return generateShortCode({
+        isTaken: (candidate) => db.select({ id: sessions.id }).from(sessions).where(eq(sessions.shortCode, candidate)).get() !== void 0
+      });
+    },
+    close() {
+      sqlite.close();
+    }
+  };
+}
+
+// src/metadata/repository.ts
+import fs3 from "fs";
+import path2 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import Database2 from "better-sqlite3";
+
 // src/metadata/schema.ts
 var sessionsMeta = sqliteTable("sessions_meta", {
-  sessionId: text("session_id").primaryKey(),
+  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()
 });
 
 // src/metadata/repository.ts
-function resolveMigrationsFolder() {
-  const here = path.dirname(fileURLToPath(import.meta.url));
+function resolveMigrationsFolder2() {
+  const here = path2.dirname(fileURLToPath2(import.meta.url));
   const candidates = [
-    path.join(here, "../../drizzle"),
-    path.join(here, "./drizzle")
+    path2.join(here, "../../drizzle"),
+    path2.join(here, "./drizzle")
   ];
-  const found = candidates.find((p) => fs2.existsSync(p));
+  const found = candidates.find((p) => fs3.existsSync(p));
   if (!found) {
     throw new Error("Could not locate drizzle migrations folder");
   }
   return found;
 }
+var CLAUDE_CODE_AGENT2 = "claude-code";
 function createMetadataRepository({
-  dataDir: dataDir2
+  dataDir: dataDir2,
+  lookupInternalId,
+  ensureSession: ensureSession2
 }) {
-  fs2.mkdirSync(dataDir2, { recursive: true });
-  const sqlite = new Database(path.join(dataDir2, "data.db"));
+  fs3.mkdirSync(dataDir2, { recursive: true });
+  const sqlite = new Database2(path2.join(dataDir2, "data.db"));
   const db = drizzle(sqlite);
-  migrate(db, { migrationsFolder: resolveMigrationsFolder() });
+  migrate(db, { migrationsFolder: resolveMigrationsFolder2() });
+  if (lookupInternalId) {
+    rekeyLegacyRows(sqlite, db, lookupInternalId, ensureSession2);
+  }
   return {
-    softDelete(sessionId) {
+    softDelete(internalId) {
       const now = /* @__PURE__ */ new Date();
       db.insert(sessionsMeta).values({
-        sessionId,
+        id: internalId,
         isDeleted: true,
         createdAt: now,
         updatedAt: now
       }).onConflictDoUpdate({
-        target: sessionsMeta.sessionId,
+        target: sessionsMeta.id,
         set: { isDeleted: true, updatedAt: now }
       }).run();
     },
-    restore(sessionId) {
+    restore(internalId) {
       const now = /* @__PURE__ */ new Date();
-      db.update(sessionsMeta).set({ isDeleted: false, updatedAt: now }).where(eq(sessionsMeta.sessionId, sessionId)).run();
+      db.update(sessionsMeta).set({ isDeleted: false, updatedAt: now }).where(eq(sessionsMeta.id, internalId)).run();
     },
-    isDeleted(sessionId) {
-      const row = db.select({ isDeleted: sessionsMeta.isDeleted }).from(sessionsMeta).where(eq(sessionsMeta.sessionId, sessionId)).get();
+    isDeleted(internalId) {
+      const row = db.select({ isDeleted: sessionsMeta.isDeleted }).from(sessionsMeta).where(eq(sessionsMeta.id, internalId)).get();
       return row?.isDeleted ?? false;
     },
     listDeletedIds() {
-      const rows = db.select({ sessionId: sessionsMeta.sessionId }).from(sessionsMeta).where(eq(sessionsMeta.isDeleted, true)).all();
-      return rows.map((r) => r.sessionId);
+      const rows = db.select({ id: sessionsMeta.id }).from(sessionsMeta).where(eq(sessionsMeta.isDeleted, true)).all();
+      return rows.map((r) => r.id);
+    },
+    getCustomTitle(internalId) {
+      const row = db.select({ customTitle: sessionsMeta.customTitle }).from(sessionsMeta).where(eq(sessionsMeta.id, internalId)).get();
+      return row?.customTitle ?? null;
+    },
+    setCustomTitle(internalId, title) {
+      const now = /* @__PURE__ */ new Date();
+      db.insert(sessionsMeta).values({
+        id: internalId,
+        customTitle: title,
+        createdAt: now,
+        updatedAt: now
+      }).onConflictDoUpdate({
+        target: sessionsMeta.id,
+        set: { customTitle: title, updatedAt: now }
+      }).run();
     }
   };
 }
-
-// src/parser.ts
-import fs3 from "fs";
-import path2 from "path";
-var COMMAND_PREFIXES = ["/clear", "/init", "/compact", "/help"];
-function isCommand(display) {
-  return COMMAND_PREFIXES.some((cmd) => display.startsWith(cmd));
+var REKEY_USER_VERSION = 4;
+function rekeyLegacyRows(sqlite, db, lookupInternalId, ensureSession2) {
+  const current = sqlite.pragma("user_version", { simple: true });
+  if (current >= REKEY_USER_VERSION) return;
+  const rows = db.select({ id: sessionsMeta.id }).from(sessionsMeta).all();
+  for (const row of rows) {
+    let target = lookupInternalId(CLAUDE_CODE_AGENT2, row.id);
+    if (target === null) {
+      if (!ensureSession2) continue;
+      target = ensureSession2(CLAUDE_CODE_AGENT2, row.id);
+    }
+    if (target === row.id) continue;
+    db.update(sessionsMeta).set({ id: target, updatedAt: /* @__PURE__ */ new Date() }).where(eq(sessionsMeta.id, row.id)).run();
+  }
+  sqlite.pragma(`user_version = ${REKEY_USER_VERSION}`);
 }
-function parseHistoryEntry(raw2) {
-  const obj = raw2;
-  return {
-    display: typeof obj.display === "string" ? obj.display : "",
-    timestamp: typeof obj.timestamp === "number" ? obj.timestamp : 0,
-    project: typeof obj.project === "string" ? obj.project : "",
-    sessionId: typeof obj.sessionId === "string" ? obj.sessionId : ""
+
+// src/ingestion/ingest.ts
+import crypto6 from "crypto";
+import fs4 from "fs";
+async function runIngestion(opts) {
+  const now = opts.now ?? (() => /* @__PURE__ */ new Date());
+  const result = {
+    scanned: 0,
+    rawInserted: 0,
+    canonicalUpserted: 0,
+    skippedByMtime: 0
   };
+  for (const plugin of opts.plugins) {
+    for await (const ref of plugin.discover(opts.env)) {
+      result.scanned += 1;
+      const stat = safeStat(ref.sourcePath);
+      const prior = opts.archive.db.select().from(sessionScanState).where(
+        and(
+          eq(sessionScanState.agent, plugin.id),
+          eq(sessionScanState.sessionId, ref.sessionId)
+        )
+      ).get();
+      ensureSession(opts.archive, plugin.id, ref.sessionId, now(), ref.project);
+      if (stat && prior && prior.lastMtimeMs === stat.mtimeMs && prior.lastSizeBytes === stat.size) {
+        result.skippedByMtime += 1;
+        continue;
+      }
+      for await (const raw2 of plugin.extractRaw(ref)) {
+        const payloadJson = JSON.stringify(raw2.payload);
+        const payloadHash = crypto6.createHash("sha256").update(payloadJson).digest("hex");
+        const existing = opts.archive.db.select({ id: rawMessages.id }).from(rawMessages).where(
+          and(
+            eq(rawMessages.agent, plugin.id),
+            eq(rawMessages.sessionId, ref.sessionId),
+            eq(rawMessages.payloadHash, payloadHash)
+          )
+        ).get();
+        let rawId;
+        if (existing) {
+          rawId = existing.id;
+        } else {
+          const inserted = opts.archive.db.insert(rawMessages).values({
+            agent: plugin.id,
+            sessionId: ref.sessionId,
+            sourcePath: raw2.sourcePath,
+            sourceLocator: raw2.sourceLocator,
+            rawPayload: payloadJson,
+            payloadHash,
+            ingestedAt: now()
+          }).returning({ id: rawMessages.id }).get();
+          rawId = inserted.id;
+          result.rawInserted += 1;
+        }
+        const canonical = plugin.normalize(raw2);
+        if (!canonical) continue;
+        const upserted = upsertCanonical(
+          opts.archive,
+          plugin.id,
+          ref.sessionId,
+          canonical,
+          rawId
+        );
+        if (upserted) result.canonicalUpserted += 1;
+      }
+      if (stat) {
+        recordScanState(
+          opts.archive,
+          plugin.id,
+          ref.sessionId,
+          ref.sourcePath,
+          stat,
+          now()
+        );
+      }
+    }
+  }
+  return result;
 }
-function listSessions(claudeDir2, historyFile = "history.jsonl") {
-  const historyPath = path2.join(claudeDir2, historyFile);
-  if (!fs3.existsSync(historyPath)) {
-    return [];
-  }
-  const content = fs3.readFileSync(historyPath, "utf-8");
-  const lines = content.trim().split("\n").filter(Boolean);
-  const grouped = /* @__PURE__ */ new Map();
-  for (const line of lines) {
-    const entry = parseHistoryEntry(JSON.parse(line));
-    if (!entry.sessionId) continue;
-    const entries = grouped.get(entry.sessionId) ?? [];
-    entries.push(entry);
-    grouped.set(entry.sessionId, entries);
-  }
-  const sessions = [];
-  for (const [id, entries] of grouped) {
-    const sorted = entries.toSorted((a, b) => a.timestamp - b.timestamp);
-    const firstNonCommand = sorted.find(
-      (e) => e.display && !isCommand(e.display)
-    );
-    const title = firstNonCommand?.display || "Untitled";
-    sessions.push({
-      id,
-      title,
-      project: sorted[0].project,
-      createdAt: sorted[0].timestamp,
-      updatedAt: sorted[sorted.length - 1].timestamp
-    });
+function safeStat(p) {
+  try {
+    return fs4.statSync(p);
+  } catch {
+    return null;
   }
-  return sessions;
 }
-var CONVERSATION_TYPES = /* @__PURE__ */ new Set(["user", "assistant"]);
-function getSessionMessages(sessionPath) {
-  if (!fs3.existsSync(sessionPath)) {
-    return [];
-  }
-  const content = fs3.readFileSync(sessionPath, "utf-8");
-  const lines = content.trim().split("\n").filter(Boolean);
-  const messages = [];
-  for (const line of lines) {
-    const entry = JSON.parse(line);
-    if (!CONVERSATION_TYPES.has(entry.type)) continue;
-    if (entry.isMeta) continue;
-    if (entry.isSidechain) continue;
-    if (!entry.message) continue;
-    messages.push({
-      role: entry.message.role,
-      content: entry.message.content,
-      timestamp: entry.timestamp ?? ""
-    });
+function recordScanState(archive2, agent, sessionId, sourcePath, stat, scannedAt) {
+  const existing = archive2.db.select({ id: sessionScanState.id }).from(sessionScanState).where(
+    and(
+      eq(sessionScanState.agent, agent),
+      eq(sessionScanState.sessionId, sessionId)
+    )
+  ).get();
+  if (existing) {
+    archive2.db.update(sessionScanState).set({
+      sourcePath,
+      lastMtimeMs: stat.mtimeMs,
+      lastSizeBytes: stat.size,
+      lastScannedAt: scannedAt
+    }).where(eq(sessionScanState.id, existing.id)).run();
+  } else {
+    archive2.db.insert(sessionScanState).values({
+      agent,
+      sessionId,
+      sourcePath,
+      lastMtimeMs: stat.mtimeMs,
+      lastSizeBytes: stat.size,
+      lastScannedAt: scannedAt
+    }).run();
   }
-  return messages;
 }
-function findSessionFile(claudeDir2, sessionId) {
-  const projectsDir = path2.join(claudeDir2, "projects");
-  if (!fs3.existsSync(projectsDir)) {
-    return null;
+function ensureSession(archive2, agent, sourceSessionId, firstSeenAt, project) {
+  const existing = archive2.db.select().from(sessions).where(
+    and(
+      eq(sessions.agent, agent),
+      eq(sessions.sourceSessionId, sourceSessionId)
+    )
+  ).get();
+  if (existing) {
+    if (project && existing.project !== project) {
+      archive2.db.update(sessions).set({ project }).where(eq(sessions.id, existing.id)).run();
+    }
+    return existing.id;
+  }
+  const id = crypto6.randomUUID();
+  const shortCode = archive2.generateShortCode();
+  archive2.db.insert(sessions).values({
+    id,
+    shortCode,
+    agent,
+    sourceSessionId,
+    firstSeenAt,
+    project: project ?? null
+  }).run();
+  return id;
+}
+function upsertCanonical(archive2, agent, sessionId, msg, rawId) {
+  const existing = archive2.db.select().from(messages).where(
+    and(
+      eq(messages.agent, agent),
+      eq(messages.sessionId, sessionId),
+      eq(messages.messageId, msg.messageId)
+    )
+  ).get();
+  const ts = parseTs(msg.ts);
+  if (!existing) {
+    archive2.db.insert(messages).values({
+      agent,
+      sessionId,
+      messageId: msg.messageId,
+      role: msg.role,
+      ts,
+      text: msg.text,
+      blocks: msg.blocks,
+      rawId
+    }).run();
+    return true;
   }
-  const projectDirs = fs3.readdirSync(projectsDir, { withFileTypes: true });
-  for (const dir of projectDirs) {
-    if (!dir.isDirectory()) continue;
-    const candidate = path2.join(projectsDir, dir.name, `${sessionId}.jsonl`);
-    if (fs3.existsSync(candidate)) {
-      return candidate;
-    }
+  if (ts.getTime() >= existing.ts.getTime()) {
+    archive2.db.update(messages).set({
+      role: msg.role,
+      ts,
+      text: msg.text,
+      blocks: msg.blocks,
+      rawId
+    }).where(eq(messages.id, existing.id)).run();
+    return true;
   }
-  return null;
+  return false;
+}
+function parseTs(ts) {
+  const d = new Date(ts);
+  if (Number.isNaN(d.getTime())) return /* @__PURE__ */ new Date(0);
+  return d;
 }
 
-// src/app.ts
-function createApp({ claudeDir: claudeDir2, dataDir: dataDir2, webDistDir: webDistDir2 }) {
-  const app2 = new Hono2();
-  const metadata = createMetadataRepository({ dataDir: dataDir2 });
-  app2.get("/api/sessions", (c) => {
-    const includeDeleted = c.req.query("includeDeleted") === "true";
-    const deleted = new Set(metadata.listDeletedIds());
-    const sessions = listSessions(claudeDir2).filter((session) => findSessionFile(claudeDir2, session.id) !== null).filter((session) => includeDeleted || !deleted.has(session.id)).map(
-      (session) => deleted.has(session.id) ? { ...session, isDeleted: true } : session
-    );
-    return c.json({ sessions });
+// src/ingestion/background.ts
+function startIngestionInBackground(opts, bg = {}) {
+  const runner = bg.runner ?? runIngestion;
+  const onError = bg.onError ?? ((err) => {
+    console.error("[ingestion] background run failed:", err);
   });
-  app2.delete("/api/sessions/:id", (c) => {
-    const sessionId = c.req.param("id");
-    if (findSessionFile(claudeDir2, sessionId) === null) {
-      return c.json({ error: "Session not found" }, 404);
-    }
-    metadata.softDelete(sessionId);
-    return c.body(null, 204);
+  const done = runner(opts).then((r) => r).catch((err) => {
+    onError(err);
+    return null;
   });
-  app2.post("/api/sessions/:id/restore", (c) => {
-    const sessionId = c.req.param("id");
-    if (findSessionFile(claudeDir2, sessionId) === null) {
-      return c.json({ error: "Session not found" }, 404);
+  return { done };
+}
+
+// src/plugins/claude-code/plugin.ts
+import fs5 from "fs";
+import path3 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 });
+    for (const project of projects) {
+      if (!project.isDirectory()) continue;
+      const projectPath = path3.join(projectsDir, project.name);
+      const files = fs5.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 sessionId = file.name.replace(/\.jsonl$/, "");
+        const cwd = readCwdFromJsonl(sourcePath);
+        yield {
+          sessionId,
+          sourcePath,
+          watchPaths: [sourcePath],
+          project: cwd ? path3.basename(cwd) : void 0
+        };
+      }
     }
-    metadata.restore(sessionId);
-    return c.body(null, 204);
-  });
-  app2.get("/api/sessions/:id", (c) => {
-    const sessionId = c.req.param("id");
-    const sessionPath = findSessionFile(claudeDir2, sessionId);
-    if (!sessionPath) {
-      return c.json({ error: "Session not found" }, 404);
+  }
+  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 });
+    let lineNo = 0;
+    for await (const line of rl) {
+      lineNo += 1;
+      if (!line) continue;
+      yield {
+        sessionId: ref.sessionId,
+        sourcePath: ref.sourcePath,
+        sourceLocator: `L${lineNo}`,
+        payload: JSON.parse(line)
+      };
     }
-    const messages = getSessionMessages(sessionPath);
-    return c.json({ messages });
-  });
-  if (webDistDir2) {
-    app2.use("*", serveStatic({ root: webDistDir2 }));
-    app2.use("*", serveStatic({ root: webDistDir2, path: "index.html" }));
   }
-  return app2;
+  normalize(raw2) {
+    const payload = raw2.payload;
+    if (!payload || typeof payload !== "object") return null;
+    if (payload.type !== "user" && payload.type !== "assistant") return null;
+    if (payload.isMeta === true) return null;
+    if (payload.isSidechain === true) return null;
+    const message = payload.message;
+    if (!message) return null;
+    const role = message.role === "assistant" ? "assistant" : "user";
+    const messageId = String(payload.uuid ?? "");
+    const ts = String(payload.timestamp ?? "");
+    if (typeof message.content === "string") {
+      const text2 = message.content;
+      return {
+        messageId,
+        role,
+        ts,
+        text: text2,
+        blocks: [{ type: "text", text: text2 }]
+      };
+    }
+    if (Array.isArray(message.content)) {
+      const blocks = [];
+      for (const block of message.content) {
+        const normalized = normalizeBlock(block);
+        if (normalized) blocks.push(normalized);
+      }
+      const text2 = blocks.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+      return { messageId, role, ts, text: text2, blocks };
+    }
+    return null;
+  }
+};
+function readCwdFromJsonl(sourcePath) {
+  let fd;
+  try {
+    fd = fs5.openSync(sourcePath, "r");
+    const buf = Buffer.alloc(64 * 1024);
+    const n = fs5.readSync(fd, buf, 0, buf.length, 0);
+    const head = buf.subarray(0, n).toString("utf-8");
+    const lines = head.split("\n");
+    if (n === buf.length) lines.pop();
+    for (const line of lines) {
+      if (!line) continue;
+      try {
+        const obj = JSON.parse(line);
+        if (typeof obj.cwd === "string" && obj.cwd.length > 0) {
+          return obj.cwd;
+        }
+      } catch {
+      }
+    }
+  } catch {
+  } finally {
+    if (fd !== void 0) {
+      try {
+        fs5.closeSync(fd);
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+function normalizeBlock(raw2) {
+  if (!raw2 || typeof raw2 !== "object") return null;
+  const b = raw2;
+  switch (b.type) {
+    case "text":
+      return { type: "text", text: String(b.text ?? "") };
+    case "thinking":
+      return { type: "thinking", thinking: String(b.thinking ?? "") };
+    case "tool_use":
+      return {
+        type: "tool_use",
+        id: String(b.id ?? ""),
+        name: String(b.name ?? ""),
+        input: b.input
+      };
+    case "tool_result":
+      return {
+        type: "tool_result",
+        toolUseId: String(b.tool_use_id ?? ""),
+        content: b.content
+      };
+    default:
+      return null;
+  }
 }
 
+// src/plugins/registry.ts
+var plugins = [new ClaudeCodePlugin()];
+
 // src/index.ts
-var __dirname = path3.dirname(fileURLToPath2(import.meta.url));
-var pkgPath = path3.join(__dirname, "../../package.json");
-var pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
+var __dirname = path4.dirname(fileURLToPath3(import.meta.url));
+var pkgPath = path4.join(__dirname, "../../package.json");
+var pkg = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
 updateNotifier({ pkg }).notify();
-var claudeDir = path3.join(os.homedir(), ".claude");
-var dataDir = path3.join(os.homedir(), ".chat-logbook");
-var webDistDir = path3.join(__dirname, "../../web/dist");
-var app = createApp({ claudeDir, dataDir, webDistDir });
+var dataDir = path4.join(os.homedir(), ".chat-logbook");
+var webDistDir = path4.join(__dirname, "../../web/dist");
 var port = Number(process.env.PORT) || 3100;
+var archive = createArchiveRepository({ dataDir });
+var metadata = createMetadataRepository({ dataDir });
+var app = createApp({ archive, metadata, webDistDir });
+startIngestionInBackground({
+  plugins,
+  archive,
+  env: { homeDir: os.homedir() }
+});
 function openBrowser(url) {
   const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
   exec(`${cmd} ${url}`);