chat-logbook 0.21.0 → 0.23.0

package/api/dist/index.js

@@ -7,7 +7,7 @@ var __export = (target, all) => {
 // src/index.ts
 import fs8 from "fs";
 import os from "os";
-import path7 from "path";
+import path8 from "path";
 import { exec } from "child_process";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
@@ -585,6 +585,9 @@ var serve = (options, listeningListener) => {
 // src/index.ts
 import updateNotifier from "update-notifier";
 
+// src/app.ts
+import { createHash } from "crypto";
+
 // ../node_modules/.pnpm/hono@4.12.9/node_modules/hono/dist/compose.js
 var compose = (middleware, onError, onNotFound) => {
   return (context, next) => {
@@ -705,26 +708,26 @@ var handleParsingNestedValues = (form, key, value) => {
 };
 
 // ../node_modules/.pnpm/hono@4.12.9/node_modules/hono/dist/utils/url.js
-var splitPath = (path8) => {
-  const paths = path8.split("/");
+var splitPath = (path9) => {
+  const paths = path9.split("/");
   if (paths[0] === "") {
     paths.shift();
   }
   return paths;
 };
 var splitRoutingPath = (routePath) => {
-  const { groups, path: path8 } = extractGroupsFromPath(routePath);
-  const paths = splitPath(path8);
+  const { groups, path: path9 } = extractGroupsFromPath(routePath);
+  const paths = splitPath(path9);
   return replaceGroupMarks(paths, groups);
 };
-var extractGroupsFromPath = (path8) => {
+var extractGroupsFromPath = (path9) => {
   const groups = [];
-  path8 = path8.replace(/\{[^}]+\}/g, (match2, index2) => {
+  path9 = path9.replace(/\{[^}]+\}/g, (match2, index2) => {
     const mark = `@${index2}`;
     groups.push([mark, match2]);
     return mark;
   });
-  return { groups, path: path8 };
+  return { groups, path: path9 };
 };
 var replaceGroupMarks = (paths, groups) => {
   for (let i = groups.length - 1; i >= 0; i--) {
@@ -781,8 +784,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 path8 = url.slice(start, end);
-      return tryDecodeURI(path8.includes("%25") ? path8.replace(/%25/g, "%2525") : path8);
+      const path9 = url.slice(start, end);
+      return tryDecodeURI(path9.includes("%25") ? path9.replace(/%25/g, "%2525") : path9);
     } else if (charCode === 63 || charCode === 35) {
       break;
     }
@@ -799,11 +802,11 @@ var mergePath = (base, sub, ...rest) => {
   }
   return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
 };
-var checkOptionalParameter = (path8) => {
-  if (path8.charCodeAt(path8.length - 1) !== 63 || !path8.includes(":")) {
+var checkOptionalParameter = (path9) => {
+  if (path9.charCodeAt(path9.length - 1) !== 63 || !path9.includes(":")) {
     return null;
   }
-  const segments = path8.split("/");
+  const segments = path9.split("/");
   const results = [];
   let basePath = "";
   segments.forEach((segment) => {
@@ -944,9 +947,9 @@ var HonoRequest = class {
    */
   path;
   bodyCache = {};
-  constructor(request, path8 = "/", matchResult = [[]]) {
+  constructor(request, path9 = "/", matchResult = [[]]) {
     this.raw = request;
-    this.path = path8;
+    this.path = path9;
     this.#matchResult = matchResult;
     this.#validatedData = {};
   }
@@ -1683,8 +1686,8 @@ var Hono = class _Hono {
         return this;
       };
     });
-    this.on = (method, path8, ...handlers) => {
-      for (const p of [path8].flat()) {
+    this.on = (method, path9, ...handlers) => {
+      for (const p of [path9].flat()) {
         this.#path = p;
         for (const m of [method].flat()) {
           handlers.map((handler) => {
@@ -1741,8 +1744,8 @@ var Hono = class _Hono {
    * app.route("/api", app2) // GET /api/user
    * ```
    */
-  route(path8, app2) {
-    const subApp = this.basePath(path8);
+  route(path9, app2) {
+    const subApp = this.basePath(path9);
     app2.routes.map((r) => {
       let handler;
       if (app2.errorHandler === errorHandler) {
@@ -1768,9 +1771,9 @@ var Hono = class _Hono {
    * const api = new Hono().basePath('/api')
    * ```
    */
-  basePath(path8) {
+  basePath(path9) {
     const subApp = this.#clone();
-    subApp._basePath = mergePath(this._basePath, path8);
+    subApp._basePath = mergePath(this._basePath, path9);
     return subApp;
   }
   /**
@@ -1844,7 +1847,7 @@ var Hono = class _Hono {
    * })
    * ```
    */
-  mount(path8, applicationHandler, options) {
+  mount(path9, applicationHandler, options) {
     let replaceRequest;
     let optionHandler;
     if (options) {
@@ -1871,7 +1874,7 @@ var Hono = class _Hono {
       return [c.env, executionContext];
     };
     replaceRequest ||= (() => {
-      const mergedPath = mergePath(this._basePath, path8);
+      const mergedPath = mergePath(this._basePath, path9);
       const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
       return (request) => {
         const url = new URL(request.url);
@@ -1886,14 +1889,14 @@ var Hono = class _Hono {
       }
       await next();
     };
-    this.#addRoute(METHOD_NAME_ALL, mergePath(path8, "*"), handler);
+    this.#addRoute(METHOD_NAME_ALL, mergePath(path9, "*"), handler);
     return this;
   }
-  #addRoute(method, path8, handler) {
+  #addRoute(method, path9, handler) {
     method = method.toUpperCase();
-    path8 = mergePath(this._basePath, path8);
-    const r = { basePath: this._basePath, path: path8, method, handler };
-    this.router.add(method, path8, [handler, r]);
+    path9 = mergePath(this._basePath, path9);
+    const r = { basePath: this._basePath, path: path9, method, handler };
+    this.router.add(method, path9, [handler, r]);
     this.routes.push(r);
   }
   #handleError(err, c) {
@@ -1906,10 +1909,10 @@ var Hono = class _Hono {
     if (method === "HEAD") {
       return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
     }
-    const path8 = this.getPath(request, { env });
-    const matchResult = this.router.match(method, path8);
+    const path9 = this.getPath(request, { env });
+    const matchResult = this.router.match(method, path9);
     const c = new Context(request, {
-      path: path8,
+      path: path9,
       matchResult,
       env,
       executionCtx,
@@ -2009,7 +2012,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, path8) {
+function match(method, path9) {
   const matchers = this.buildAllMatchers();
   const match2 = ((method2, path22) => {
     const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
@@ -2025,7 +2028,7 @@ function match(method, path8) {
     return [matcher[1][index2], match3];
   });
   this.match = match2;
-  return match2(method, path8);
+  return match2(method, path9);
 }
 
 // ../node_modules/.pnpm/hono@4.12.9/node_modules/hono/dist/router/reg-exp-router/node.js
@@ -2140,12 +2143,12 @@ var Node = class _Node {
 var Trie = class {
   #context = { varIndex: 0 };
   #root = new Node();
-  insert(path8, index2, pathErrorCheckOnly) {
+  insert(path9, index2, pathErrorCheckOnly) {
     const paramAssoc = [];
     const groups = [];
     for (let i = 0; ; ) {
       let replaced = false;
-      path8 = path8.replace(/\{[^}]+\}/g, (m) => {
+      path9 = path9.replace(/\{[^}]+\}/g, (m) => {
         const mark = `@\\${i}`;
         groups[i] = [mark, m];
         i++;
@@ -2156,7 +2159,7 @@ var Trie = class {
         break;
       }
     }
-    const tokens = path8.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+    const tokens = path9.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 +2198,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(path8) {
-  return wildcardRegExpCache[path8] ??= new RegExp(
-    path8 === "*" ? "" : `^${path8.replace(
+function buildWildcardRegExp(path9) {
+  return wildcardRegExpCache[path9] ??= new RegExp(
+    path9 === "*" ? "" : `^${path9.replace(
       /\/\*$|([.\\+*[^\]$()])/g,
       (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)"
     )}$`
@@ -2219,17 +2222,17 @@ function buildMatcherFromPreprocessedRoutes(routes) {
   );
   const staticMap = /* @__PURE__ */ Object.create(null);
   for (let i = 0, j = -1, len = routesWithStaticPathFlag.length; i < len; i++) {
-    const [pathErrorCheckOnly, path8, handlers] = routesWithStaticPathFlag[i];
+    const [pathErrorCheckOnly, path9, handlers] = routesWithStaticPathFlag[i];
     if (pathErrorCheckOnly) {
-      staticMap[path8] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
+      staticMap[path9] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
     } else {
       j++;
     }
     let paramAssoc;
     try {
-      paramAssoc = trie.insert(path8, j, pathErrorCheckOnly);
+      paramAssoc = trie.insert(path9, j, pathErrorCheckOnly);
     } catch (e) {
-      throw e === PATH_ERROR ? new UnsupportedPathError(path8) : e;
+      throw e === PATH_ERROR ? new UnsupportedPathError(path9) : e;
     }
     if (pathErrorCheckOnly) {
       continue;
@@ -2263,12 +2266,12 @@ function buildMatcherFromPreprocessedRoutes(routes) {
   }
   return [regexp, handlerMap, staticMap];
 }
-function findMiddleware(middleware, path8) {
+function findMiddleware(middleware, path9) {
   if (!middleware) {
     return void 0;
   }
   for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
-    if (buildWildcardRegExp(k).test(path8)) {
+    if (buildWildcardRegExp(k).test(path9)) {
       return [...middleware[k]];
     }
   }
@@ -2282,7 +2285,7 @@ var RegExpRouter = class {
     this.#middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
     this.#routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
   }
-  add(method, path8, handler) {
+  add(method, path9, handler) {
     const middleware = this.#middleware;
     const routes = this.#routes;
     if (!middleware || !routes) {
@@ -2297,18 +2300,18 @@ var RegExpRouter = class {
         });
       });
     }
-    if (path8 === "/*") {
-      path8 = "*";
+    if (path9 === "/*") {
+      path9 = "*";
     }
-    const paramCount = (path8.match(/\/:/g) || []).length;
-    if (/\*$/.test(path8)) {
-      const re = buildWildcardRegExp(path8);
+    const paramCount = (path9.match(/\/:/g) || []).length;
+    if (/\*$/.test(path9)) {
+      const re = buildWildcardRegExp(path9);
       if (method === METHOD_NAME_ALL) {
         Object.keys(middleware).forEach((m) => {
-          middleware[m][path8] ||= findMiddleware(middleware[m], path8) || findMiddleware(middleware[METHOD_NAME_ALL], path8) || [];
+          middleware[m][path9] ||= findMiddleware(middleware[m], path9) || findMiddleware(middleware[METHOD_NAME_ALL], path9) || [];
         });
       } else {
-        middleware[method][path8] ||= findMiddleware(middleware[method], path8) || findMiddleware(middleware[METHOD_NAME_ALL], path8) || [];
+        middleware[method][path9] ||= findMiddleware(middleware[method], path9) || findMiddleware(middleware[METHOD_NAME_ALL], path9) || [];
       }
       Object.keys(middleware).forEach((m) => {
         if (method === METHOD_NAME_ALL || method === m) {
@@ -2326,7 +2329,7 @@ var RegExpRouter = class {
       });
       return;
     }
-    const paths = checkOptionalParameter(path8) || [path8];
+    const paths = checkOptionalParameter(path9) || [path9];
     for (let i = 0, len = paths.length; i < len; i++) {
       const path22 = paths[i];
       Object.keys(routes).forEach((m) => {
@@ -2353,13 +2356,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((path8) => [path8, r[method][path8]]) : [];
+      const ownRoute = r[method] ? Object.keys(r[method]).map((path9) => [path9, r[method][path9]]) : [];
       if (ownRoute.length !== 0) {
         hasOwnRoute ||= true;
         routes.push(...ownRoute);
       } else if (method !== METHOD_NAME_ALL) {
         routes.push(
-          ...Object.keys(r[METHOD_NAME_ALL]).map((path8) => [path8, r[METHOD_NAME_ALL][path8]])
+          ...Object.keys(r[METHOD_NAME_ALL]).map((path9) => [path9, r[METHOD_NAME_ALL][path9]])
         );
       }
     });
@@ -2379,13 +2382,13 @@ var SmartRouter = class {
   constructor(init) {
     this.#routers = init.routers;
   }
-  add(method, path8, handler) {
+  add(method, path9, handler) {
     if (!this.#routes) {
       throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
-    this.#routes.push([method, path8, handler]);
+    this.#routes.push([method, path9, handler]);
   }
-  match(method, path8) {
+  match(method, path9) {
     if (!this.#routes) {
       throw new Error("Fatal error");
     }
@@ -2400,7 +2403,7 @@ var SmartRouter = class {
         for (let i2 = 0, len2 = routes.length; i2 < len2; i2++) {
           router.add(...routes[i2]);
         }
-        res = router.match(method, path8);
+        res = router.match(method, path9);
       } catch (e) {
         if (e instanceof UnsupportedPathError) {
           continue;
@@ -2450,10 +2453,10 @@ var Node2 = class _Node2 {
     }
     this.#patterns = [];
   }
-  insert(method, path8, handler) {
+  insert(method, path9, handler) {
     this.#order = ++this.#order;
     let curNode = this;
-    const parts = splitRoutingPath(path8);
+    const parts = splitRoutingPath(path9);
     const possibleKeys = [];
     for (let i = 0, len = parts.length; i < len; i++) {
       const p = parts[i];
@@ -2502,12 +2505,12 @@ var Node2 = class _Node2 {
       }
     }
   }
-  search(method, path8) {
+  search(method, path9) {
     const handlerSets = [];
     this.#params = emptyParams;
     const curNode = this;
     let curNodes = [curNode];
-    const parts = splitPath(path8);
+    const parts = splitPath(path9);
     const curNodesQueue = [];
     const len = parts.length;
     let partOffsets = null;
@@ -2549,13 +2552,13 @@ var Node2 = class _Node2 {
           if (matcher instanceof RegExp) {
             if (partOffsets === null) {
               partOffsets = new Array(len);
-              let offset = path8[0] === "/" ? 1 : 0;
+              let offset = path9[0] === "/" ? 1 : 0;
               for (let p = 0; p < len; p++) {
                 partOffsets[p] = offset;
                 offset += parts[p].length + 1;
               }
             }
-            const restPathString = path8.substring(partOffsets[i]);
+            const restPathString = path9.substring(partOffsets[i]);
             const m = matcher.exec(restPathString);
             if (m) {
               params[name] = m[0];
@@ -2608,18 +2611,18 @@ var TrieRouter = class {
   constructor() {
     this.#node = new Node2();
   }
-  add(method, path8, handler) {
-    const results = checkOptionalParameter(path8);
+  add(method, path9, handler) {
+    const results = checkOptionalParameter(path9);
     if (results) {
       for (let i = 0, len = results.length; i < len; i++) {
         this.#node.insert(method, results[i], handler);
       }
       return;
     }
-    this.#node.insert(method, path8, handler);
+    this.#node.insert(method, path9, handler);
   }
-  match(method, path8) {
-    return this.#node.search(method, path8);
+  match(method, path9) {
+    return this.#node.search(method, path9);
   }
 };
 
@@ -2899,10 +2902,10 @@ var createStreamBody = (stream2) => {
   });
   return body;
 };
-var getStats = (path8) => {
+var getStats = (path9) => {
   let stats;
   try {
-    stats = statSync(path8);
+    stats = statSync(path9);
   } catch {
   }
   return stats;
@@ -2945,21 +2948,21 @@ var serveStatic = (options = { root: "" }) => {
         return next();
       }
     }
-    let path8 = join(
+    let path9 = join(
       root,
       !optionPath && options.rewriteRequestPath ? options.rewriteRequestPath(filename, c) : filename
     );
-    let stats = getStats(path8);
+    let stats = getStats(path9);
     if (stats && stats.isDirectory()) {
       const indexFile = options.index ?? "index.html";
-      path8 = join(path8, indexFile);
-      stats = getStats(path8);
+      path9 = join(path9, indexFile);
+      stats = getStats(path9);
     }
     if (!stats) {
-      await options.onNotFound?.(path8, c);
+      await options.onNotFound?.(path9, c);
       return next();
     }
-    const mimeType = getMimeType(path8);
+    const mimeType = getMimeType(path9);
     c.header("Content-Type", mimeType || "application/octet-stream");
     if (options.precompressed && (!mimeType || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
       const acceptEncodingSet = new Set(
@@ -2969,12 +2972,12 @@ var serveStatic = (options = { root: "" }) => {
         if (!acceptEncodingSet.has(encoding)) {
           continue;
         }
-        const precompressedStats = getStats(path8 + ENCODINGS[encoding]);
+        const precompressedStats = getStats(path9 + ENCODINGS[encoding]);
         if (precompressedStats) {
           c.header("Content-Encoding", encoding);
           c.header("Vary", "Accept-Encoding", { append: true });
           stats = precompressedStats;
-          path8 = path8 + ENCODINGS[encoding];
+          path9 = path9 + ENCODINGS[encoding];
           break;
         }
       }
@@ -2988,7 +2991,7 @@ var serveStatic = (options = { root: "" }) => {
       result = c.body(null);
     } else if (!range) {
       c.header("Content-Length", size.toString());
-      result = c.body(createStreamBody(createReadStream(path8)), 200);
+      result = c.body(createStreamBody(createReadStream(path9)), 200);
     } else {
       c.header("Accept-Ranges", "bytes");
       c.header("Date", stats.birthtime.toUTCString());
@@ -2999,12 +3002,12 @@ var serveStatic = (options = { root: "" }) => {
         end = size - 1;
       }
       const chunksize = end - start + 1;
-      const stream2 = createReadStream(path8, { start, end });
+      const stream2 = createReadStream(path9, { start, end });
       c.header("Content-Length", chunksize.toString());
       c.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
       result = c.body(createStreamBody(stream2), 206);
     }
-    await options.onFound?.(path8, c);
+    await options.onFound?.(path9, c);
     return result;
   };
 };
@@ -3238,7 +3241,9 @@ function toApiBlock(block) {
     return {
       type: "tool_result",
       tool_use_id: String(block.toolUseId ?? ""),
-      content: block.content
+      content: block.content,
+      ...block.isError === true ? { is_error: true } : {},
+      ...typeof block.filePath === "string" && Array.isArray(block.patch) ? { file_path: block.filePath, patch: block.patch } : {}
     };
   }
   return block;
@@ -3374,9 +3379,12 @@ function createChatReader({
     if (!visibility.isVisible(row.id)) return null;
     const rows = archive2.read.listMessagesByChat(row.agent, row.sourceId);
     return rows.map((m) => ({
+      id: m.messageId,
       role: m.role,
       content: m.blocks.map(toApiBlock),
-      timestamp: m.ts.toISOString()
+      timestamp: m.ts.toISOString(),
+      ...m.model === null ? {} : { model: m.model },
+      ...m.effort === null ? {} : { effort: m.effort }
     }));
   }
   return {
@@ -3391,6 +3399,450 @@ function createChatReader({
 // src/list-contract.ts
 var MAX_PAGE_LIMIT = 200;
 
+// src/plugins/claude-code/plugin.ts
+import fs2 from "fs";
+import path3 from "path";
+import readline from "readline";
+
+// src/plugins/visualize-widget.ts
+var SHOW_WIDGET_TOOL = "mcp__visualize__show_widget";
+function svgWidgetCode(block) {
+  if (!block || typeof block !== "object") return null;
+  const b = block;
+  if (b.type !== "tool_use" || b.name !== SHOW_WIDGET_TOOL) return null;
+  const input = b.input;
+  const code = input?.widget_code;
+  if (typeof code !== "string") return null;
+  return code.trimStart().startsWith("<svg") ? code : null;
+}
+var RAMPS = {
+  "c-purple": { fill: "#3C3489", stroke: "#AFA9EC", title: "#CECBF6" },
+  "c-teal": { fill: "#085041", stroke: "#5DCAA5", title: "#9FE1CB" },
+  "c-coral": { fill: "#712B13", stroke: "#F0997B", title: "#F5C4B3" },
+  "c-pink": { fill: "#72243E", stroke: "#ED93B1", title: "#F4C0D1" },
+  "c-gray": { fill: "#444441", stroke: "#B4B2A9", title: "#D3D1C7" },
+  "c-blue": { fill: "#0C447C", stroke: "#85B7EB", title: "#B5D4F4" },
+  "c-green": { fill: "#27500A", stroke: "#97C459", title: "#C0DD97" },
+  "c-amber": { fill: "#633806", stroke: "#EF9F27", title: "#FAC775" },
+  "c-red": { fill: "#791F1F", stroke: "#F09595", title: "#F7C1C1" }
+};
+var TEXT_PRIMARY = "#eee8d5";
+var TEXT_SECONDARY = "#93a1a1";
+var FONT_SANS = "ui-sans-serif, system-ui, -apple-system, 'Segoe UI', sans-serif";
+function widgetStylesheet() {
+  const ramps = Object.entries(RAMPS).map(
+    ([name, c]) => `.${name}>rect,.${name}>circle,.${name}>ellipse,rect.${name},circle.${name},ellipse.${name}{fill:${c.fill};stroke:${c.stroke};stroke-width:1.5}.${name}>text.t,.${name}>text.th{fill:${c.title}}.${name}>text.ts{fill:${c.stroke}}`
+  ).join("");
+  return `text{font-family:${FONT_SANS}}.t{font-size:14px;fill:${TEXT_PRIMARY}}.th{font-size:14px;font-weight:500;fill:${TEXT_PRIMARY}}.ts{font-size:12px;fill:${TEXT_SECONDARY}}` + ramps;
+}
+function themeWidgetSvg(svg) {
+  const root = /<svg\b[^>]*>/.exec(svg);
+  if (!root) return svg;
+  const sized = withIntrinsicSize(root[0]);
+  const at = root.index + root[0].length;
+  return svg.slice(0, root.index) + sized + `<style>${widgetStylesheet()}</style>` + svg.slice(at);
+}
+function withIntrinsicSize(rootTag) {
+  if (/\s(width|height)\s*=/.test(rootTag)) return rootTag;
+  const viewBox = /\bviewBox\s*=\s*"([^"]*)"/.exec(rootTag);
+  if (!viewBox) return rootTag;
+  const parts = viewBox[1].trim().split(/[\s,]+/).map(Number);
+  if (parts.length !== 4 || parts.some((n) => !Number.isFinite(n))) {
+    return rootTag;
+  }
+  const [, , width, height] = parts;
+  if (width <= 0 || height <= 0) return rootTag;
+  return `${rootTag.slice(0, -1)} width="${width}" height="${height}">`;
+}
+
+// src/plugins/mcp-tool-name.ts
+var PREFIX = "mcp__";
+var SEPARATOR = "__";
+function mcpServerName(toolName) {
+  if (!toolName.startsWith(PREFIX)) return null;
+  const rest = toolName.slice(PREFIX.length);
+  const end = rest.indexOf(SEPARATOR);
+  const server2 = end === -1 ? rest : rest.slice(0, end);
+  if (!server2) return null;
+  return server2.replace(/_/g, " ");
+}
+
+// src/plugins/claude-code/actions.ts
+function getString(input, key) {
+  if (typeof input !== "object" || input === null) return void 0;
+  const value = input[key];
+  return typeof value === "string" && value !== "" ? value : void 0;
+}
+var FILE_KINDS = {
+  Edit: "edit",
+  MultiEdit: "edit",
+  Write: "write",
+  Read: "read"
+};
+var SEARCH_TOOLS = /* @__PURE__ */ new Set(["Grep", "Glob", "WebSearch", "ToolSearch"]);
+function firstLine(text2) {
+  return text2?.split("\n", 1)[0];
+}
+function phrase(value) {
+  return value ? { object: { type: "phrase", value } } : {};
+}
+function path2(value) {
+  return value ? { object: { type: "path", value } } : {};
+}
+function detail(value) {
+  return value ? { detail: value } : {};
+}
+function toolAction(name, input) {
+  if (name === "Bash") {
+    const command = getString(input, "command");
+    const said = getString(input, "description") ?? firstLine(command);
+    return { kind: "execute", ...phrase(said), ...detail(command) };
+  }
+  if (name === "Agent" || name === "SendMessage") {
+    const task = getString(input, "description") ?? getString(input, "summary");
+    return { kind: "delegate", ...phrase(task) };
+  }
+  if (SEARCH_TOOLS.has(name)) {
+    const looked = getString(input, "pattern") ?? getString(input, "query");
+    return { kind: "search", ...phrase(looked) };
+  }
+  const fileKind = FILE_KINDS[name];
+  if (fileKind) {
+    return { kind: fileKind, ...path2(getString(input, "file_path")) };
+  }
+  if (name === "WebFetch") {
+    return { kind: "read", ...phrase(getString(input, "url")) };
+  }
+  return { kind: "other", ...phrase(mcpServerName(name) ?? name) };
+}
+
+// src/plugins/claude-code/plugin.ts
+var ClaudeCodePlugin = class {
+  id = "claude-code";
+  displayName = "Claude Code";
+  async *discover(env) {
+    const projectsDir = path3.join(env.homeDir, ".claude", "projects");
+    if (!fs2.existsSync(projectsDir)) return;
+    const projects = fs2.readdirSync(projectsDir, { withFileTypes: true });
+    for (const project of projects) {
+      if (!project.isDirectory()) continue;
+      const projectPath = path3.join(projectsDir, project.name);
+      const files = fs2.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 sourceId = file.name.replace(/\.jsonl$/, "");
+        const cwd = await readCwdFromJsonl(sourcePath);
+        yield {
+          sourceId,
+          sourcePath,
+          watchPaths: [sourcePath],
+          project: cwd ? path3.basename(cwd) : void 0,
+          projectPath: cwd ?? void 0
+        };
+      }
+    }
+  }
+  async *extractRaw(ref) {
+    if (!fs2.existsSync(ref.sourcePath)) return;
+    const stream2 = fs2.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;
+      if (!line) continue;
+      yield {
+        sourceId: ref.sourceId,
+        sourcePath: ref.sourcePath,
+        sourceLocator: `L${lineNo}`,
+        payload: JSON.parse(line)
+      };
+    }
+  }
+  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 ?? "");
+    const model = typeof message.model === "string" && message.model !== "" ? { model: message.model } : {};
+    const effort = typeof payload.effort === "string" && payload.effort !== "" ? { effort: payload.effort } : {};
+    const cwd = typeof payload.cwd === "string" ? payload.cwd : void 0;
+    if (typeof message.content === "string") {
+      const command = parseCommandMarkup(message.content);
+      if (command) {
+        const commandLine = `${command.name} ${command.args}`.trim();
+        return {
+          messageId,
+          role,
+          ts,
+          text: commandLine,
+          blocks: [{ type: "command", name: command.name, args: command.args }]
+        };
+      }
+      const system = parseSystemNoise(message.content);
+      if (system) {
+        return {
+          messageId,
+          role,
+          ts,
+          text: system.summary,
+          blocks: [system]
+        };
+      }
+      return {
+        messageId,
+        role,
+        ts,
+        text: translateFileMentions(message.content, cwd, asPath),
+        blocks: [
+          {
+            type: "text",
+            text: translateFileMentions(message.content, cwd, asLink)
+          }
+        ],
+        ...model,
+        ...effort
+      };
+    }
+    if (Array.isArray(message.content)) {
+      const raw3 = message.content.flatMap(
+        (block, index2) => normalizeBlock(block, messageId, index2, payload.toolUseResult)
+      );
+      const blocks = raw3.map(
+        (block) => block.type === "text" ? { ...block, text: translateFileMentions(block.text, cwd, asLink) } : block
+      );
+      const text2 = raw3.filter((b) => b.type === "text").map((b) => translateFileMentions(b.text, cwd, asPath)).join("\n");
+      return { messageId, role, ts, text: text2, blocks, ...model, ...effort };
+    }
+    return null;
+  }
+  resolveImage(ref, loadPayload) {
+    const address = parseImageRef(ref);
+    if (!address) return null;
+    const record = loadPayload(address.messageId);
+    if (!record || typeof record !== "object") return null;
+    const message = record.message;
+    if (!message || !Array.isArray(message.content)) return null;
+    const block = message.content[address.index];
+    if (!block) return null;
+    const widget = svgWidgetCode(block);
+    if (widget) {
+      return {
+        mediaType: "image/svg+xml",
+        bytes: Buffer.from(themeWidgetSvg(widget), "utf8"),
+        rendered: true
+      };
+    }
+    if (block.type !== "image") return null;
+    const source = block.source;
+    if (!source || source.type !== "base64") return null;
+    const mediaType = String(source.media_type ?? "");
+    const data = source.data;
+    if (!mediaType || typeof data !== "string") return null;
+    return { mediaType, bytes: Buffer.from(data, "base64") };
+  }
+};
+async function readCwdFromJsonl(sourcePath) {
+  try {
+    const stream2 = fs2.createReadStream(sourcePath, { encoding: "utf-8" });
+    const rl = readline.createInterface({ input: stream2, crlfDelay: Infinity });
+    try {
+      for await (const line of rl) {
+        if (!line) continue;
+        let obj;
+        try {
+          obj = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (typeof obj.cwd === "string" && obj.cwd.length > 0) {
+          return obj.cwd;
+        }
+      }
+    } finally {
+      rl.close();
+      stream2.destroy();
+    }
+  } catch {
+  }
+  return void 0;
+}
+var COMMAND_NAME_RE = /<command-name>([\s\S]*?)<\/command-name>/;
+var COMMAND_ARGS_RE = /<command-args>([\s\S]*?)<\/command-args>/;
+function parseCommandMarkup(content) {
+  const nameMatch = COMMAND_NAME_RE.exec(content);
+  if (!nameMatch) return null;
+  const name = nameMatch[1].trim();
+  const argsMatch = COMMAND_ARGS_RE.exec(content);
+  const args = argsMatch ? argsMatch[1].trim() : "";
+  return { name, args };
+}
+var TASK_NOTIFICATION_RE = /<task-notification>[\s\S]*<\/task-notification>/;
+var TASK_SUMMARY_RE = /<summary>([\s\S]*?)<\/summary>/;
+var LOCAL_COMMAND_STDOUT_RE = /<local-command-stdout>([\s\S]*?)<\/local-command-stdout>/;
+var ANSI_SGR_RE = /\u001b\[[0-9;]*m/g;
+function stripAnsi(text2) {
+  return text2.replace(ANSI_SGR_RE, "");
+}
+function parseSystemNoise(content) {
+  const notification = TASK_NOTIFICATION_RE.exec(content);
+  if (notification) {
+    const summaryMatch = TASK_SUMMARY_RE.exec(notification[0]);
+    return {
+      type: "system",
+      kind: "task-notification",
+      summary: summaryMatch?.[1].trim() || "Task notification",
+      detail: notification[0]
+    };
+  }
+  const stdout = LOCAL_COMMAND_STDOUT_RE.exec(content);
+  if (stdout) {
+    return {
+      type: "system",
+      kind: "local-command-stdout",
+      summary: stripAnsi(stdout[1]).trim(),
+      detail: ""
+    };
+  }
+  return null;
+}
+var FILE_MENTION_RE = /(^|\s)@(?:"([^"\n]+)"|(\S+))/g;
+var CODE_SEGMENT_RE = /```[\s\S]*?```|`[^`\n]*`/g;
+var asLink = (mentioned, cwd) => `[${mentioned}](${fileUrl(resolveAgainst(mentioned, cwd))})`;
+var asPath = (mentioned) => mentioned;
+function translateFileMentions(text2, cwd, write) {
+  let out = "";
+  let last = 0;
+  for (const code of text2.matchAll(CODE_SEGMENT_RE)) {
+    out += translateProse(text2.slice(last, code.index), cwd, write) + code[0];
+    last = code.index + code[0].length;
+  }
+  return out + translateProse(text2.slice(last), cwd, write);
+}
+function translateProse(text2, cwd, write) {
+  return text2.replace(
+    FILE_MENTION_RE,
+    (match2, lead, quoted, bare) => {
+      const mentioned = quoted ?? bare;
+      if (!looksLikeFilePath(mentioned)) return match2;
+      return `${lead}${write(mentioned, cwd)}`;
+    }
+  );
+}
+function resolveAgainst(mentioned, cwd) {
+  if (!cwd) return mentioned;
+  if (mentioned.startsWith("/") || mentioned.startsWith("~")) return mentioned;
+  return path3.posix.join(cwd, mentioned);
+}
+function looksLikeFilePath(mentioned) {
+  if (mentioned.endsWith("/")) return true;
+  const basename3 = mentioned.slice(mentioned.lastIndexOf("/") + 1);
+  if (/^\.[A-Za-z0-9]/.test(basename3)) return true;
+  return /^[^.].*\.[A-Za-z0-9]+$/.test(basename3);
+}
+function fileUrl(filePath) {
+  return `file://${encodeURI(filePath).replace(/[()]/g, encodeURIComponent)}`;
+}
+function imageRef(messageId, index2) {
+  return `${messageId}.${index2}`;
+}
+function parseImageRef(ref) {
+  const dot = ref.lastIndexOf(".");
+  if (dot <= 0) return null;
+  const index2 = Number(ref.slice(dot + 1));
+  if (!Number.isInteger(index2) || index2 < 0) return null;
+  return { messageId: ref.slice(0, dot), index: index2 };
+}
+function normalizeBlock(raw2, messageId, index2, toolUseResult) {
+  const one = normalizeOneBlock(raw2, messageId, index2, toolUseResult);
+  if (!one) return [];
+  if (one.type === "tool_use" && svgWidgetCode(raw2)) {
+    return [
+      one,
+      {
+        type: "image",
+        mediaType: "image/svg+xml",
+        ref: imageRef(messageId, index2)
+      }
+    ];
+  }
+  return [one];
+}
+function editedFile(toolUseResult) {
+  if (!toolUseResult || typeof toolUseResult !== "object") return {};
+  const r = toolUseResult;
+  if (typeof r.filePath !== "string" || !r.filePath) return {};
+  if (!Array.isArray(r.structuredPatch)) return {};
+  const patch = r.structuredPatch.filter(isPatchHunk);
+  if (patch.length > 0) return { filePath: r.filePath, patch };
+  const created = createdFilePatch(r);
+  if (created) return { filePath: r.filePath, patch: created };
+  return {};
+}
+function createdFilePatch(r) {
+  if (r.type !== "create" || typeof r.content !== "string" || !r.content) {
+    return null;
+  }
+  const content = r.content.endsWith("\n") ? r.content.slice(0, -1) : r.content;
+  const lines = content.split("\n").map((line) => `+${line}`);
+  return [
+    { oldStart: 0, oldLines: 0, newStart: 1, newLines: lines.length, lines }
+  ];
+}
+function isPatchHunk(hunk) {
+  if (!hunk || typeof hunk !== "object") return false;
+  const h = hunk;
+  return typeof h.oldStart === "number" && typeof h.oldLines === "number" && typeof h.newStart === "number" && typeof h.newLines === "number" && Array.isArray(h.lines) && h.lines.every((line) => typeof line === "string");
+}
+function normalizeOneBlock(raw2, messageId, index2, toolUseResult) {
+  if (!raw2 || typeof raw2 !== "object") return null;
+  const b = raw2;
+  switch (b.type) {
+    case "image": {
+      const source = b.source;
+      if (!source || source.type !== "base64") return null;
+      const mediaType = String(source.media_type ?? "");
+      if (!mediaType) return null;
+      return { type: "image", mediaType, ref: imageRef(messageId, index2) };
+    }
+    case "text":
+      return { type: "text", text: String(b.text ?? "") };
+    case "thinking":
+      return { type: "thinking", thinking: String(b.thinking ?? "") };
+    case "tool_use": {
+      const name = String(b.name ?? "");
+      return {
+        type: "tool_use",
+        id: String(b.id ?? ""),
+        name,
+        input: b.input,
+        action: toolAction(name, b.input)
+      };
+    }
+    case "tool_result":
+      return {
+        type: "tool_result",
+        toolUseId: String(b.tool_use_id ?? ""),
+        content: b.content,
+        // Only carried when the tool actually failed: a `false` on every
+        // successful result would grow the stored block for nothing.
+        ...b.is_error === true ? { isError: true } : {},
+        ...editedFile(toolUseResult)
+      };
+    default:
+      return null;
+  }
+}
+
+// src/plugins/registry.ts
+var plugins = [new ClaudeCodePlugin()];
+
 // src/app.ts
 var STREAM_HEARTBEAT_MS = 25e3;
 function createApp({
@@ -3661,6 +4113,52 @@ function createApp({
     }
     return c.json({ messages: messages2 });
   });
+  app2.get("/api/chats/:id/images/:ref", (c) => {
+    const row = reader.findChat(c.req.param("id"));
+    if (!row) return c.json({ error: "Chat not found" }, 404);
+    const plugin = plugins.find((p) => p.id === row.agent);
+    if (!plugin?.resolveImage) {
+      return c.json({ error: "Image not found" }, 404);
+    }
+    const image = plugin.resolveImage(c.req.param("ref"), (messageId) => {
+      const payload = archive2.read.findRawPayloadForMessage(
+        row.agent,
+        row.sourceId,
+        messageId
+      );
+      if (payload === null) return null;
+      try {
+        return JSON.parse(payload);
+      } catch {
+        return null;
+      }
+    });
+    if (!image) return c.json({ error: "Image not found" }, 404);
+    if (image.rendered) {
+      const etag = `"${createHash("sha256").update(image.bytes).digest("base64url").slice(0, 27)}"`;
+      if (c.req.header("if-none-match") === etag) {
+        return c.body(null, 304, { ETag: etag, "Cache-Control": "no-cache" });
+      }
+      return c.body(new Uint8Array(image.bytes), 200, {
+        "Content-Type": image.mediaType,
+        "Cache-Control": "no-cache",
+        ETag: etag,
+        "Content-Security-Policy": "default-src 'none'; style-src 'unsafe-inline'; sandbox",
+        "X-Content-Type-Options": "nosniff"
+      });
+    }
+    return c.body(new Uint8Array(image.bytes), 200, {
+      "Content-Type": image.mediaType,
+      // Verbatim archived bytes never change, so the browser keeps them forever.
+      "Cache-Control": "public, max-age=31536000, immutable",
+      // Archived bytes are the Agent's, not ours — an SVG widget may carry a
+      // script. The pane renders these through `<img>`, which already refuses
+      // to run scripts or load external resources; saying it again in the
+      // headers keeps that true for anyone opening the URL on its own.
+      "Content-Security-Policy": "default-src 'none'; style-src 'unsafe-inline'; sandbox",
+      "X-Content-Type-Options": "nosniff"
+    });
+  });
   app2.get("/api/tags", (c) => {
     return c.json({ tags: tags3.listTags() });
   });
@@ -5063,7 +5561,7 @@ var QueryPromise = class {
 function mapResultRow(columns, row, joinsNotNullableMap) {
   const nullifyMap = {};
   const result = columns.reduce(
-    (result2, { path: path8, field }, columnIndex) => {
+    (result2, { path: path9, field }, columnIndex) => {
       let decoder;
       if (is(field, Column)) {
         decoder = field;
@@ -5075,8 +5573,8 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
         decoder = field.sql.decoder;
       }
       let node = result2;
-      for (const [pathChunkIndex, pathChunk] of path8.entries()) {
-        if (pathChunkIndex < path8.length - 1) {
+      for (const [pathChunkIndex, pathChunk] of path9.entries()) {
+        if (pathChunkIndex < path9.length - 1) {
           if (!(pathChunk in node)) {
             node[pathChunk] = {};
           }
@@ -5084,8 +5582,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) && path8.length === 2) {
-            const objectName = path8[0];
+          if (joinsNotNullableMap && is(field, Column) && path9.length === 2) {
+            const objectName = path9[0];
             if (!(objectName in nullifyMap)) {
               nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
             } else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== getTableName(field.table)) {
@@ -5645,8 +6143,8 @@ function mapRelationalRow(tablesConfig, tableConfig, row, buildQueryResultSelect
 }
 
 // src/storage/openStore.ts
-import fs3 from "fs";
-import path2 from "path";
+import fs4 from "fs";
+import path4 from "path";
 import { fileURLToPath } from "url";
 import Database2 from "better-sqlite3";
 
@@ -9255,20 +9753,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 fs2 from "fs";
+import fs3 from "fs";
 function readMigrationFiles(config) {
   const migrationFolderTo = config.migrationsFolder;
   const migrationQueries = [];
   const journalPath = `${migrationFolderTo}/meta/_journal.json`;
-  if (!fs2.existsSync(journalPath)) {
+  if (!fs3.existsSync(journalPath)) {
     throw new Error(`Can't find meta/_journal.json file`);
   }
-  const journalAsString = fs2.readFileSync(`${migrationFolderTo}/meta/_journal.json`).toString();
+  const journalAsString = fs3.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 = fs2.readFileSync(`${migrationFolderTo}/${journalEntry.tag}.sql`).toString();
+      const query = fs3.readFileSync(`${migrationFolderTo}/${journalEntry.tag}.sql`).toString();
       const result = query.split("--> statement-breakpoint").map((it) => {
         return it;
       });
@@ -9293,12 +9791,12 @@ function migrate(db, config) {
 
 // src/storage/openStore.ts
 function resolveMigrationsFolder(callerUrl, migrationsSubdir) {
-  const here = path2.dirname(fileURLToPath(callerUrl));
+  const here = path4.dirname(fileURLToPath(callerUrl));
   const candidates = [
-    path2.join(here, "../..", migrationsSubdir),
-    path2.join(here, ".", migrationsSubdir)
+    path4.join(here, "../..", migrationsSubdir),
+    path4.join(here, ".", migrationsSubdir)
   ];
-  const found = candidates.find((p) => fs3.existsSync(p));
+  const found = candidates.find((p) => fs4.existsSync(p));
   if (!found) {
     throw new Error(`Could not locate migrations folder "${migrationsSubdir}"`);
   }
@@ -9312,8 +9810,8 @@ function openStore({
   schema
 }) {
   const migrationsFolder = resolveMigrationsFolder(callerUrl, migrationsSubdir);
-  fs3.mkdirSync(dataDir2, { recursive: true });
-  const sqlite = new Database2(path2.join(dataDir2, dbFile));
+  fs4.mkdirSync(dataDir2, { recursive: true });
+  const sqlite = new Database2(path4.join(dataDir2, dbFile));
   const db = drizzle(sqlite, { schema });
   migrate(db, { migrationsFolder });
   return { db, sqlite };
@@ -9332,7 +9830,12 @@ __export(schema_exports, {
 var archiveMeta = sqliteTable("archive_meta", {
   id: integer("id").primaryKey(),
   archiveUuid: text("archive_uuid").notNull(),
-  createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull()
+  createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull(),
+  // The normalize-output version this archive's Normalized layer was last built
+  // at. Startup compares it to the code's NORMALIZE_VERSION and re-normalizes
+  // from Raw once per bump, so a new block kind reaches dormant chats without
+  // re-reading Source (ADR-0023). Additive, default 0 for existing archives.
+  normalizeVersion: integer("normalize_version").notNull().default(0)
 });
 var schemaVersion = sqliteTable("schema_version", {
   version: integer("version").primaryKey(),
@@ -9401,6 +9904,13 @@ var messages = sqliteTable(
     ts: integer("ts", { mode: "timestamp_ms" }).notNull(),
     text: text("text").notNull(),
     blocks: text("blocks", { mode: "json" }).notNull(),
+    // The model id the Agent recorded on this message (ADR-0023). Nullable:
+    // reader turns record none, and neither do rows normalized before #195 —
+    // those get backfilled by the next re-normalize pass.
+    model: text("model"),
+    // The reasoning effort the Agent recorded for this message (ADR-0023).
+    // Nullable on the same terms as `model`: many turns record none.
+    effort: text("effort"),
     rawId: integer("raw_id").notNull().references(() => rawMessages.id)
   },
   (t) => [
@@ -9440,6 +9950,16 @@ 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();
     },
+    findRawPayloadForMessage(agent, sourceId, messageId) {
+      const row = db.select({ rawPayload: rawMessages.rawPayload }).from(messages).innerJoin(rawMessages, eq(messages.rawId, rawMessages.id)).where(
+        and(
+          eq(messages.agent, agent),
+          eq(messages.sourceId, sourceId),
+          eq(messages.messageId, messageId)
+        )
+      ).get();
+      return row?.rawPayload ?? null;
+    },
     listChatTsRanges(opts) {
       const scope = opts?.sourceIds !== void 0 ? inArray(messages.sourceId, opts.sourceIds) : sql`1 = 1`;
       return db.select({
@@ -9486,6 +10006,15 @@ function createArchiveReadSeam(db) {
     },
     listIngestionEvents() {
       return db.select().from(ingestionEvents).all();
+    },
+    listRawMessages() {
+      return db.select({
+        id: rawMessages.id,
+        agent: rawMessages.agent,
+        sourceId: rawMessages.sourceId,
+        sourcePath: rawMessages.sourcePath,
+        rawPayload: rawMessages.rawPayload
+      }).from(rawMessages).orderBy(asc(rawMessages.id)).all();
     }
   };
 }
@@ -9532,6 +10061,16 @@ function createArchiveRepository({
       }
       return row.archiveUuid;
     },
+    getNormalizeVersion() {
+      const row = db.select().from(archiveMeta).get();
+      if (!row) {
+        throw new Error("archive_meta row missing after initialization");
+      }
+      return row.normalizeVersion;
+    },
+    setNormalizeVersion(version2) {
+      db.update(archiveMeta).set({ normalizeVersion: version2 }).where(eq(archiveMeta.id, 1)).run();
+    },
     getAppliedMigrations() {
       return db.select().from(schemaVersion).all().map((r) => ({ version: r.version, appliedAt: r.appliedAt }));
     },
@@ -9615,6 +10154,8 @@ function createArchiveRepository({
           ts,
           text: message.text,
           blocks: message.blocks,
+          model: message.model ?? null,
+          effort: message.effort ?? null,
           rawId
         }).run();
         return true;
@@ -9625,6 +10166,8 @@ function createArchiveRepository({
           ts,
           text: message.text,
           blocks: message.blocks,
+          model: message.model ?? null,
+          effort: message.effort ?? null,
           rawId
         }).where(eq(messages.id, existing2.id)).run();
         return true;
@@ -9726,8 +10269,8 @@ function createCheckpointRepository({
 }
 
 // src/metadata/repository.ts
-import fs4 from "fs";
-import path3 from "path";
+import fs5 from "fs";
+import path5 from "path";
 
 // src/metadata/schema.ts
 var schema_exports3 = {};
@@ -9807,11 +10350,11 @@ function computeSortKey(input) {
 var DB_FILE = "metadata.db";
 var LEGACY_DB_FILE = "data.db";
 function migrateLegacyDbFile(dataDir2) {
-  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);
+  const legacy = path5.join(dataDir2, LEGACY_DB_FILE);
+  const current = path5.join(dataDir2, DB_FILE);
+  if (!fs5.existsSync(legacy)) return;
+  if (fs5.existsSync(current)) return;
+  fs5.renameSync(legacy, current);
 }
 var CLAUDE_CODE_AGENT = "claude-code";
 function createMetadataRepository({
@@ -10055,7 +10598,7 @@ function createTagRepository({
 }
 
 // src/ingestion/ingest.ts
-import fs5 from "fs";
+import fs6 from "fs";
 async function runIngestion(opts) {
   const now = opts.now ?? (() => /* @__PURE__ */ new Date());
   const changedChatIds = /* @__PURE__ */ new Set();
@@ -10125,7 +10668,7 @@ async function runIngestion(opts) {
 }
 function safeStat(p) {
   try {
-    return fs5.statSync(p);
+    return fs6.statSync(p);
   } catch {
     return null;
   }
@@ -10144,6 +10687,55 @@ function startIngestionInBackground(opts, bg = {}) {
   return { done };
 }
 
+// src/ingestion/renormalize.ts
+function renormalizeFromRaw({
+  plugins: plugins2,
+  archive: archive2
+}) {
+  const pluginById = new Map(plugins2.map((p) => [p.id, p]));
+  const result = { scanned: 0, normalizedUpserted: 0 };
+  for (const raw2 of archive2.read.listRawMessages()) {
+    result.scanned += 1;
+    const plugin = pluginById.get(raw2.agent);
+    if (!plugin) continue;
+    let payload;
+    try {
+      payload = JSON.parse(raw2.rawPayload);
+    } catch {
+      continue;
+    }
+    const record = {
+      sourceId: raw2.sourceId,
+      sourcePath: raw2.sourcePath,
+      // Re-normalize works entirely off the stored payload; the plugin does not
+      // read the file, so a synthetic locator is enough.
+      sourceLocator: "renormalize",
+      payload
+    };
+    const normalized = plugin.normalize(record);
+    if (!normalized) continue;
+    const upserted = archive2.upsertNormalizedMessage({
+      agent: raw2.agent,
+      sourceId: raw2.sourceId,
+      message: normalized,
+      rawId: raw2.id
+    });
+    if (upserted) result.normalizedUpserted += 1;
+  }
+  return result;
+}
+var NORMALIZE_VERSION = 11;
+function runRenormalizeIfStale({
+  plugins: plugins2,
+  archive: archive2,
+  targetVersion = NORMALIZE_VERSION
+}) {
+  if (archive2.getNormalizeVersion() >= targetVersion) return false;
+  renormalizeFromRaw({ plugins: plugins2, archive: archive2 });
+  archive2.setNormalizeVersion(targetVersion);
+  return true;
+}
+
 // ../node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/index.js
 import { EventEmitter } from "events";
 import { stat as statcb, Stats } from "fs";
@@ -10234,7 +10826,7 @@ var ReaddirpStream = class extends Readable3 {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path8) => statMethod(path8, { bigint: true });
+      this._stat = (path9) => statMethod(path9, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -10259,8 +10851,8 @@ var ReaddirpStream = class extends Readable3 {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path8, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path8));
+          const { path: path9, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path9));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -10300,20 +10892,20 @@ var ReaddirpStream = class extends Readable3 {
       this.reading = false;
     }
   }
-  async _exploreDir(path8, depth) {
+  async _exploreDir(path9, depth) {
     let files;
     try {
-      files = await readdir(path8, this._rdOptions);
+      files = await readdir(path9, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path8 };
+    return { files, depth, path: path9 };
   }
-  async _formatEntry(dirent, path8) {
+  async _formatEntry(dirent, path9) {
     let entry;
     const basename3 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path8, basename3));
+      const fullPath = presolve(pjoin(path9, basename3));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename3 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -10713,16 +11305,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path8, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path9, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path8);
-    emitRaw(rawEvent, evPath, { watchedPath: path8 });
-    if (evPath && path8 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path8, evPath), KEY_LISTENERS, sp.join(path8, evPath));
+    listener(path9);
+    emitRaw(rawEvent, evPath, { watchedPath: path9 });
+    if (evPath && path9 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path9, evPath), KEY_LISTENERS, sp.join(path9, evPath));
     }
   };
   try {
-    return fs_watch(path8, {
+    return fs_watch(path9, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -10738,12 +11330,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path8, fullPath, options, handlers) => {
+var setFsWatchListener = (path9, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher2;
   if (!options.persistent) {
-    watcher2 = createFsWatchInstance(path8, options, listener, errHandler, rawEmitter);
+    watcher2 = createFsWatchInstance(path9, options, listener, errHandler, rawEmitter);
     if (!watcher2)
       return;
     return watcher2.close.bind(watcher2);
@@ -10754,7 +11346,7 @@ var setFsWatchListener = (path8, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher2 = createFsWatchInstance(
-      path8,
+      path9,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -10769,7 +11361,7 @@ var setFsWatchListener = (path8, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path8, "r");
+          const fd = await open(path9, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -10800,7 +11392,7 @@ var setFsWatchListener = (path8, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path8, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path9, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -10822,7 +11414,7 @@ var setFsWatchFileListener = (path8, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path8, curr));
+          foreach(cont.listeners, (listener2) => listener2(path9, curr));
         }
       })
     };
@@ -10852,13 +11444,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path8, listener) {
+  _watchWithNodeFs(path9, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path8);
-    const basename3 = sp.basename(path8);
+    const directory = sp.dirname(path9);
+    const basename3 = sp.basename(path9);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename3);
-    const absolutePath = sp.resolve(path8);
+    const absolutePath = sp.resolve(path9);
     const options = {
       persistent: opts.persistent
     };
@@ -10868,12 +11460,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename3) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path8, absolutePath, options, {
+      closer = setFsWatchFileListener(path9, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path8, absolutePath, options, {
+      closer = setFsWatchListener(path9, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -10895,7 +11487,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename3))
       return;
-    const listener = async (path8, newStats) => {
+    const listener = async (path9, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -10909,11 +11501,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path8);
+            this.fsw._closeFile(path9);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path8, closer2);
+              this.fsw._addPathCloser(path9, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -10945,7 +11537,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, path8, item) {
+  async _handleSymlink(entry, directory, path9, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -10955,7 +11547,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path8);
+        linkPath = await fsrealpath(path9);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -10965,12 +11557,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, path8, entry.stats);
+          this.fsw._emit(EV.CHANGE, path9, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path8, entry.stats);
+        this.fsw._emit(EV.ADD, path9, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -11000,9 +11592,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path8 = sp.join(directory, item);
+      let path9 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path8, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path9, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -11011,8 +11603,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path8 = sp.join(dir, sp.relative(dir, path8));
-        this._addToNodeFs(path8, initialAdd, wh, depth + 1);
+        path9 = sp.join(dir, sp.relative(dir, path9));
+        this._addToNodeFs(path9, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve3, reject) => {
@@ -11081,13 +11673,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path8, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path9, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path8) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path9) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path8);
+    const wh = this.fsw._getWatchHelpers(path9);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -11103,8 +11695,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path8);
-        const targetPath = follow ? await fsrealpath(path8) : path8;
+        const absPath = sp.resolve(path9);
+        const targetPath = follow ? await fsrealpath(path9) : path9;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -11114,29 +11706,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path8) : path8;
+        const targetPath = follow ? await fsrealpath(path9) : path9;
         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, path8, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path9, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path8), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path9), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path8, closer);
+        this.fsw._addPathCloser(path9, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path8;
+        return path9;
       }
     }
   }
@@ -11179,24 +11771,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path8) {
-  if (typeof path8 !== "string")
+function normalizePath(path9) {
+  if (typeof path9 !== "string")
     throw new Error("string expected");
-  path8 = sp2.normalize(path8);
-  path8 = path8.replace(/\\/g, "/");
+  path9 = sp2.normalize(path9);
+  path9 = path9.replace(/\\/g, "/");
   let prepend = false;
-  if (path8.startsWith("//"))
+  if (path9.startsWith("//"))
     prepend = true;
-  path8 = path8.replace(DOUBLE_SLASH_RE, "/");
+  path9 = path9.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path8 = "/" + path8;
-  return path8;
+    path9 = "/" + path9;
+  return path9;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path8 = normalizePath(testString);
+  const path9 = normalizePath(testString);
   for (let index2 = 0; index2 < patterns.length; index2++) {
     const pattern = patterns[index2];
-    if (pattern(path8, stats)) {
+    if (pattern(path9, stats)) {
       return true;
     }
   }
@@ -11234,19 +11826,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-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));
+var normalizePathToUnix = (path9) => toUnix(sp2.normalize(toUnix(path9)));
+var normalizeIgnored = (cwd = "") => (path9) => {
+  if (typeof path9 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path9) ? path9 : sp2.join(cwd, path9));
   } else {
-    return path8;
+    return path9;
   }
 };
-var getAbsolutePath = (path8, cwd) => {
-  if (sp2.isAbsolute(path8)) {
-    return path8;
+var getAbsolutePath = (path9, cwd) => {
+  if (sp2.isAbsolute(path9)) {
+    return path9;
   }
-  return sp2.join(cwd, path8);
+  return sp2.join(cwd, path9);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -11311,10 +11903,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path8, follow, fsw) {
+  constructor(path9, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path8;
-    this.path = path8 = path8.replace(REPLACER_RE, "");
+    const watchPath = path9;
+    this.path = path9 = path9.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -11454,20 +12046,20 @@ var FSWatcher = class extends EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path8) => {
-        const absPath = getAbsolutePath(path8, cwd);
+      paths = paths.map((path9) => {
+        const absPath = getAbsolutePath(path9, cwd);
         return absPath;
       });
     }
-    paths.forEach((path8) => {
-      this._removeIgnoredPath(path8);
+    paths.forEach((path9) => {
+      this._removeIgnoredPath(path9);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path8) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path8, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path9) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path9, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -11489,17 +12081,17 @@ var FSWatcher = class extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path8) => {
-      if (!sp2.isAbsolute(path8) && !this._closers.has(path8)) {
+    paths.forEach((path9) => {
+      if (!sp2.isAbsolute(path9) && !this._closers.has(path9)) {
         if (cwd)
-          path8 = sp2.join(cwd, path8);
-        path8 = sp2.resolve(path8);
+          path9 = sp2.join(cwd, path9);
+        path9 = sp2.resolve(path9);
       }
-      this._closePath(path8);
-      this._addIgnoredPath(path8);
-      if (this._watched.has(path8)) {
+      this._closePath(path9);
+      this._addIgnoredPath(path9);
+      if (this._watched.has(path9)) {
         this._addIgnoredPath({
-          path: path8,
+          path: path9,
           recursive: true
         });
       }
@@ -11563,38 +12155,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, path8, stats) {
+  async _emit(event, path9, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path8 = sp2.normalize(path8);
+      path9 = sp2.normalize(path9);
     if (opts.cwd)
-      path8 = sp2.relative(opts.cwd, path8);
-    const args = [path8];
+      path9 = sp2.relative(opts.cwd, path9);
+    const args = [path9];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path8))) {
+    if (awf && (pw = this._pendingWrites.get(path9))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path8, [event, ...args]);
+        this._pendingUnlinks.set(path9, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path9) => {
+          this._pendingUnlinks.forEach((entry, path10) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path9);
+            this._pendingUnlinks.delete(path10);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path8)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path9)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path8);
+        this._pendingUnlinks.delete(path9);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -11612,16 +12204,16 @@ var FSWatcher = class extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path8, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path9, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path8, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path9, 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, path8) : path8;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path9) : path9;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -11652,23 +12244,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, path8, timeout) {
+  _throttle(actionType, path9, 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(path8);
+    const actionPath = action2.get(path9);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action2.get(path8);
+      const item = action2.get(path9);
       const count = item ? item.count : 0;
-      action2.delete(path8);
+      action2.delete(path9);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -11676,7 +12268,7 @@ var FSWatcher = class extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action2.set(path8, thr);
+    action2.set(path9, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -11690,44 +12282,44 @@ var FSWatcher = class extends EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path8, threshold, event, awfEmit) {
+  _awaitWriteFinish(path9, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path8;
-    if (this.options.cwd && !sp2.isAbsolute(path8)) {
-      fullPath = sp2.join(this.options.cwd, path8);
+    let fullPath = path9;
+    if (this.options.cwd && !sp2.isAbsolute(path9)) {
+      fullPath = sp2.join(this.options.cwd, path9);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path8)) {
+        if (err || !writes.has(path9)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path8).lastChange = now2;
+          writes.get(path9).lastChange = now2;
         }
-        const pw = writes.get(path8);
+        const pw = writes.get(path9);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path8);
+          writes.delete(path9);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path8)) {
-      writes.set(path8, {
+    if (!writes.has(path9)) {
+      writes.set(path9, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path8);
+          writes.delete(path9);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -11738,8 +12330,8 @@ var FSWatcher = class extends EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path8, stats) {
-    if (this.options.atomic && DOT_RE.test(path8))
+  _isIgnored(path9, stats) {
+    if (this.options.atomic && DOT_RE.test(path9))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -11749,17 +12341,17 @@ var FSWatcher = class extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path8, stats);
+    return this._userIgnored(path9, stats);
   }
-  _isntIgnored(path8, stat4) {
-    return !this._isIgnored(path8, stat4);
+  _isntIgnored(path9, stat4) {
+    return !this._isIgnored(path9, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path8) {
-    return new WatchHelper(path8, this.options.followSymlinks, this);
+  _getWatchHelpers(path9) {
+    return new WatchHelper(path9, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -11791,63 +12383,63 @@ var FSWatcher = class extends EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    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))
+    const path9 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path9);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path9) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path9, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path8);
+    const wp = this._getWatchedDir(path9);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path8, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path9, 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 = path8;
+    let relPath = path9;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path8);
+      relPath = sp2.relative(this.options.cwd, path9);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path8);
+    this._watched.delete(path9);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path8))
-      this._emit(eventName, path8);
-    this._closePath(path8);
+    if (wasTracked && !this._isIgnored(path9))
+      this._emit(eventName, path9);
+    this._closePath(path9);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path8) {
-    this._closeFile(path8);
-    const dir = sp2.dirname(path8);
-    this._getWatchedDir(dir).remove(sp2.basename(path8));
+  _closePath(path9) {
+    this._closeFile(path9);
+    const dir = sp2.dirname(path9);
+    this._getWatchedDir(dir).remove(sp2.basename(path9));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path8) {
-    const closers = this._closers.get(path8);
+  _closeFile(path9) {
+    const closers = this._closers.get(path9);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path8);
+    this._closers.delete(path9);
   }
-  _addPathCloser(path8, closer) {
+  _addPathCloser(path9, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path8);
+    let list = this._closers.get(path9);
     if (!list) {
       list = [];
-      this._closers.set(path8, list);
+      this._closers.set(path9, list);
     }
     list.push(closer);
   }
@@ -11945,13 +12537,13 @@ function startWatcher(opts) {
   }
   return {
     ready,
-    notifyChange(path8) {
-      if (watcher2) watcher2.emit("change", path8);
-      else scheduleIngest(path8);
+    notifyChange(path9) {
+      if (watcher2) watcher2.emit("change", path9);
+      else scheduleIngest(path9);
     },
-    notifyUnlink(path8) {
-      if (watcher2) watcher2.emit("unlink", path8);
-      else recordUnlink(path8);
+    notifyUnlink(path9) {
+      if (watcher2) watcher2.emit("unlink", path9);
+      else recordUnlink(path9);
     },
     async close() {
       closed = true;
@@ -11962,139 +12554,6 @@ function startWatcher(opts) {
   };
 }
 
-// src/plugins/claude-code/plugin.ts
-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 = 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 = 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 = path4.join(projectPath, file.name);
-        const sourceId = file.name.replace(/\.jsonl$/, "");
-        const cwd = await readCwdFromJsonl(sourcePath);
-        yield {
-          sourceId,
-          sourcePath,
-          watchPaths: [sourcePath],
-          project: cwd ? path4.basename(cwd) : void 0,
-          projectPath: cwd ?? void 0
-        };
-      }
-    }
-  }
-  async *extractRaw(ref) {
-    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;
-      if (!line) continue;
-      yield {
-        sourceId: ref.sourceId,
-        sourcePath: ref.sourcePath,
-        sourceLocator: `L${lineNo}`,
-        payload: JSON.parse(line)
-      };
-    }
-  }
-  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;
-  }
-};
-async function readCwdFromJsonl(sourcePath) {
-  try {
-    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;
-        let obj;
-        try {
-          obj = JSON.parse(line);
-        } catch {
-          continue;
-        }
-        if (typeof obj.cwd === "string" && obj.cwd.length > 0) {
-          return obj.cwd;
-        }
-      }
-    } finally {
-      rl.close();
-      stream2.destroy();
-    }
-  } 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/cli/argv.ts
 var DEFAULT_PORT = 3100;
 function parseCliArgs(argv, env = {}) {
@@ -12150,28 +12609,28 @@ Environment:
 `;
 
 // src/config/data-dir.ts
-import path5 from "path";
+import path6 from "path";
 function resolveDataDir(env, homeDir) {
   const override = env.CHAT_LOGBOOK_DATA_DIR?.trim();
   if (override) {
-    return path5.resolve(override);
+    return path6.resolve(override);
   }
-  return path5.join(homeDir, ".chat-logbook");
+  return path6.join(homeDir, ".chat-logbook");
 }
 
 // src/list-counts.ts
 import fs7 from "fs";
-import path6 from "path";
+import path7 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), {
+  const archive2 = new Database3(path7.join(dataDir2, ARCHIVE_DB2), {
     readonly: true
   });
-  const metadataPath = path6.join(dataDir2, METADATA_DB2);
+  const metadataPath = path7.join(dataDir2, METADATA_DB2);
   const hasMetadata = fs7.existsSync(metadataPath);
   if (hasMetadata) {
     archive2.prepare("ATTACH DATABASE ? AS meta").run(metadataPath);
@@ -12307,8 +12766,8 @@ function reconcileTitleSortKeys({
 }
 
 // src/index.ts
-var __dirname = path7.dirname(fileURLToPath2(import.meta.url));
-var pkgPath = path7.join(__dirname, "../../package.json");
+var __dirname = path8.dirname(fileURLToPath2(import.meta.url));
+var pkgPath = path8.join(__dirname, "../../package.json");
 var pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf-8"));
 var action = parseCliArgs(process.argv.slice(2), {
   PORT: process.env.PORT
@@ -12330,9 +12789,14 @@ var dataDir = resolveDataDir(
   { CHAT_LOGBOOK_DATA_DIR: process.env.CHAT_LOGBOOK_DATA_DIR },
   os.homedir()
 );
-var webDistDir = path7.join(__dirname, "../../web/dist");
+var webDistDir = path8.join(__dirname, "../../web/dist");
 var port = action.port;
 var archive = createArchiveRepository({ dataDir });
+try {
+  runRenormalizeIfStale({ plugins, archive });
+} catch (err) {
+  console.error("[renormalize] startup pass failed:", err);
+}
 var checkpoint = createCheckpointRepository({ dataDir });
 var metadata = createMetadataRepository({ dataDir });
 var tags2 = createTagRepository({ dataDir });