mcp-agents-memory 0.9.1 → 0.9.4

package/build/index.js

@@ -1655,11 +1655,11 @@ var require_pg_connection_string = __commonJS({
         config2.client_encoding = result.searchParams.get("encoding");
         return config2;
       }
-      const hostname2 = dummyHost ? "" : result.hostname;
+      const hostname8 = dummyHost ? "" : result.hostname;
       if (!config2.host) {
-        config2.host = decodeURIComponent(hostname2);
-      } else if (hostname2 && /^%2f/i.test(hostname2)) {
-        result.pathname = hostname2 + result.pathname;
+        config2.host = decodeURIComponent(hostname8);
+      } else if (hostname8 && /^%2f/i.test(hostname8)) {
+        result.pathname = hostname8 + result.pathname;
       }
       if (!config2.port) {
         config2.port = result.port;
@@ -3079,7 +3079,7 @@ var require_dist = __commonJS({
     function parse3(stream, callback) {
       const parser = new parser_1.Parser();
       stream.on("data", (buffer) => parser.parse(buffer, callback));
-      return new Promise((resolve2) => stream.on("end", () => resolve2()));
+      return new Promise((resolve) => stream.on("end", () => resolve()));
     }
     exports.parse = parse3;
   }
@@ -3810,12 +3810,12 @@ var require_client = __commonJS({
           this._connect(callback);
           return;
         }
-        return new this._Promise((resolve2, reject) => {
+        return new this._Promise((resolve, reject) => {
           this._connect((error2) => {
             if (error2) {
               reject(error2);
             } else {
-              resolve2(this);
+              resolve(this);
             }
           });
         });
@@ -4161,8 +4161,8 @@ var require_client = __commonJS({
           readTimeout = config2.query_timeout || this.connectionParameters.query_timeout;
           query = new Query2(config2, values, callback);
           if (!query.callback) {
-            result = new this._Promise((resolve2, reject) => {
-              query.callback = (err2, res) => err2 ? reject(err2) : resolve2(res);
+            result = new this._Promise((resolve, reject) => {
+              query.callback = (err2, res) => err2 ? reject(err2) : resolve(res);
             }).catch((err2) => {
               Error.captureStackTrace(err2);
               throw err2;
@@ -4239,8 +4239,8 @@ var require_client = __commonJS({
         if (cb) {
           this.connection.once("end", cb);
         } else {
-          return new this._Promise((resolve2) => {
-            this.connection.once("end", resolve2);
+          return new this._Promise((resolve) => {
+            this.connection.once("end", resolve);
           });
         }
       }
@@ -4289,8 +4289,8 @@ var require_pg_pool = __commonJS({
       const cb = function(err2, client2) {
         err2 ? rej(err2) : res(client2);
       };
-      const result = new Promise2(function(resolve2, reject) {
-        res = resolve2;
+      const result = new Promise2(function(resolve, reject) {
+        res = resolve;
         rej = reject;
       }).catch((err2) => {
         Error.captureStackTrace(err2);
@@ -4351,7 +4351,7 @@ var require_pg_pool = __commonJS({
         if (typeof Promise2.try === "function") {
           return Promise2.try(f);
         }
-        return new Promise2((resolve2) => resolve2(f()));
+        return new Promise2((resolve) => resolve(f()));
       }
       _isFull() {
         return this._clients.length >= this.options.max;
@@ -4744,8 +4744,8 @@ var require_query2 = __commonJS({
     NativeQuery.prototype._getPromise = function() {
       if (this._promise) return this._promise;
       this._promise = new Promise(
-        function(resolve2, reject) {
-          this._once("end", resolve2);
+        function(resolve, reject) {
+          this._once("end", resolve);
           this._once("error", reject);
         }.bind(this)
       );
@@ -4922,12 +4922,12 @@ var require_client2 = __commonJS({
         this._connect(callback);
         return;
       }
-      return new this._Promise((resolve2, reject) => {
+      return new this._Promise((resolve, reject) => {
         this._connect((error2) => {
           if (error2) {
             reject(error2);
           } else {
-            resolve2(this);
+            resolve(this);
           }
         });
       });
@@ -4951,8 +4951,8 @@ var require_client2 = __commonJS({
         query = new NativeQuery(config2, values, callback);
         if (!query.callback) {
           let resolveOut, rejectOut;
-          result = new this._Promise((resolve2, reject) => {
-            resolveOut = resolve2;
+          result = new this._Promise((resolve, reject) => {
+            resolveOut = resolve;
             rejectOut = reject;
           }).catch((err2) => {
             Error.captureStackTrace(err2);
@@ -5012,8 +5012,8 @@ var require_client2 = __commonJS({
       }
       let result;
       if (!cb) {
-        result = new this._Promise(function(resolve2, reject) {
-          cb = (err2) => err2 ? reject(err2) : resolve2();
+        result = new this._Promise(function(resolve, reject) {
+          cb = (err2) => err2 ? reject(err2) : resolve();
         });
       }
       this.native.end(function() {
@@ -11652,7 +11652,7 @@ var require_crypto = __commonJS({
       MAC_INFO,
       bindingAvailable: !!binding,
       init: (() => {
-        return new Promise(async (resolve2, reject) => {
+        return new Promise(async (resolve, reject) => {
           try {
             POLY1305_WASM_MODULE = await require_poly1305()();
             POLY1305_RESULT_MALLOC = POLY1305_WASM_MODULE._malloc(16);
@@ -11664,7 +11664,7 @@ var require_crypto = __commonJS({
           } catch (ex) {
             return reject(ex);
           }
-          resolve2();
+          resolve();
         });
       })(),
       NullCipher,
@@ -12922,7 +12922,7 @@ var require_agent = __commonJS({
     "use strict";
     var { Socket } = __require("net");
     var { Duplex } = __require("stream");
-    var { resolve: resolve2 } = __require("path");
+    var { resolve } = __require("path");
     var { readFile } = __require("fs");
     var { execFile, spawn: spawn2 } = __require("child_process");
     var { isParsedKey, parseKey } = require_keyParser();
@@ -13058,7 +13058,7 @@ var require_agent = __commonJS({
       const RET_ERR_BINSTDIN = 13;
       const RET_ERR_BINSTDOUT = 14;
       const RET_ERR_BADLEN = 15;
-      const EXEPATH = resolve2(__dirname, "..", "util/pagent.exe");
+      const EXEPATH = resolve(__dirname, "..", "util/pagent.exe");
       const ERROR = {
         [RET_ERR_BADARGS]: new Error("Invalid pagent.exe arguments"),
         [RET_ERR_UNAVAILABLE]: new Error("Pageant is not running"),
@@ -17103,7 +17103,7 @@ var require_Protocol = __commonJS({
           sendPacket(this, this._packetRW.write.finalize(packet));
         });
       }
-      authHostbased(username, pubKey, hostname2, userlocal, keyAlgo, cbSign) {
+      authHostbased(username, pubKey, hostname8, userlocal, keyAlgo, cbSign) {
         if (this._server)
           throw new Error("Client-only method called in server mode");
         pubKey = parseKey(pubKey);
@@ -17122,7 +17122,7 @@ var require_Protocol = __commonJS({
         const pubKeyLen = pubKey.length;
         const sessionID = this._kex.sessionID;
         const sesLen = sessionID.length;
-        const hostnameLen = Buffer.byteLength(hostname2);
+        const hostnameLen = Buffer.byteLength(hostname8);
         const userlocalLen = Buffer.byteLength(userlocal);
         const data = Buffer.allocUnsafe(
           4 + sesLen + 1 + 4 + userLen + 4 + 14 + 4 + 9 + 4 + algoLen + 4 + pubKeyLen + 4 + hostnameLen + 4 + userlocalLen
@@ -17142,7 +17142,7 @@ var require_Protocol = __commonJS({
         writeUInt32BE(data, pubKeyLen, p += algoLen);
         data.set(pubKey, p += 4);
         writeUInt32BE(data, hostnameLen, p += pubKeyLen);
-        data.utf8Write(hostname2, p += 4, hostnameLen);
+        data.utf8Write(hostname8, p += 4, hostnameLen);
         writeUInt32BE(data, userlocalLen, p += hostnameLen);
         data.utf8Write(userlocal, p += 4, userlocalLen);
         cbSign(data, (signature) => {
@@ -25300,7 +25300,7 @@ var require_tunnel_ssh = __commonJS({
   "node_modules/tunnel-ssh/index.js"(exports) {
     var net = __require("net");
     var { Client: Client2 } = require_lib4();
-    var os5 = __require("os");
+    var os8 = __require("os");
     function autoClose(server, connection) {
       connection.on("close", () => {
         server.getConnections((error2, count) => {
@@ -25315,7 +25315,7 @@ var require_tunnel_ssh = __commonJS({
       if (!serverOptions.port && !serverOptions.path) {
         serverOptions = null;
       }
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve, reject) => {
         let server = net.createServer();
         let errorHandler = function(error2) {
           reject(error2);
@@ -25325,14 +25325,14 @@ var require_tunnel_ssh = __commonJS({
         server.listen(serverOptions);
         server.on("listening", () => {
           process.removeListener("uncaughtException", errorHandler);
-          resolve2(server);
+          resolve(server);
         });
       });
     }
     async function createSSHConnection(config2) {
-      return new Promise(function(resolve2, reject) {
+      return new Promise(function(resolve, reject) {
         let conn = new Client2();
-        conn.on("ready", () => resolve2(conn));
+        conn.on("ready", () => resolve(conn));
         conn.on("error", reject);
         conn.connect(config2);
       });
@@ -25342,7 +25342,7 @@ var require_tunnel_ssh = __commonJS({
       let forwardOptionsLocal = Object.assign({ dstAddr: "0.0.0.0" }, forwardOptions);
       let tunnelOptionsLocal = Object.assign({ autoClose: false, reconnectOnError: false }, tunnelOptions || {});
       let server, sshConnection;
-      return new Promise(async function(resolve2, reject) {
+      return new Promise(async function(resolve, reject) {
         try {
           sshConnection = await createSSHConnection(sshOptionslocal);
           addListenerSshConnection(sshConnection);
@@ -25407,7 +25407,7 @@ var require_tunnel_ssh = __commonJS({
             }
           );
         }
-        resolve2([server, sshConnection]);
+        resolve([server, sshConnection]);
       });
     }
     exports.createTunnel = createTunnel2;
@@ -25487,7 +25487,7 @@ var require_main = __commonJS({
   "node_modules/dotenv/lib/main.js"(exports, module) {
     var fs8 = __require("fs");
     var path8 = __require("path");
-    var os5 = __require("os");
+    var os8 = __require("os");
     var crypto3 = __require("crypto");
     var packageJson2 = require_package2();
     var version2 = packageJson2.version;
@@ -25610,7 +25610,7 @@ var require_main = __commonJS({
       return null;
     }
     function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path8.join(os5.homedir(), envPath.slice(1)) : envPath;
+      return envPath[0] === "~" ? path8.join(os8.homedir(), envPath.slice(1)) : envPath;
     }
     function _configVault(options) {
       const debug = Boolean(options && options.debug);
@@ -25788,8 +25788,8 @@ import { fileURLToPath } from "url";
 function configSearchPaths() {
   const paths = [];
   if (process.env.MEMORY_CONFIG_PATH) paths.push(process.env.MEMORY_CONFIG_PATH);
-  paths.push(path.resolve(process.cwd(), ".env"));
   paths.push(path.join(os.homedir(), ".config", "mcp-agents-memory", ".env"));
+  paths.push(path.resolve(process.cwd(), ".env"));
   paths.push(path.resolve(__dirname2, "..", ".env"));
   return paths;
 }
@@ -25882,7 +25882,7 @@ var init_db = __esm({
                 dstAddr: process.env.DB_HOST || "localhost",
                 dstPort: parseInt(process.env.DB_PORT || "5432")
               };
-              return new Promise((resolve2, reject) => {
+              return new Promise((resolve, reject) => {
                 (0, import_tunnel_ssh.createTunnel)(tunnelOptions, serverOptions, sshOptions, forwardOptions).then(async ([server, conn]) => {
                   this.tunnelServer = server;
                   this.tunnelConn = conn;
@@ -25903,7 +25903,7 @@ var init_db = __esm({
                     await pool2.query("SELECT 1");
                     console.error("\u2705 Database connection verified.");
                     this.pool = pool2;
-                    resolve2(pool2);
+                    resolve(pool2);
                   } catch (err2) {
                     console.error("\u274C Database connection probe failed:", err2);
                     await pool2.end().catch(() => {
@@ -25955,11 +25955,11 @@ var init_db = __esm({
           this.tunnelConn = null;
         }
         if (this.tunnelServer) {
-          await new Promise((resolve2) => {
+          await new Promise((resolve) => {
             this.tunnelServer.close(() => {
               this.tunnelServer = null;
               console.error("\u{1F512} SSH Tunnel closed.");
-              resolve2();
+              resolve();
             });
           });
         }
@@ -28920,7 +28920,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve2.call(this, root, ref);
+      let _sch = resolve.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a3 = root.localRefs) === null || _a3 === void 0 ? void 0 : _a3[ref];
         const { schemaId } = this.opts;
@@ -28947,7 +28947,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve2(root, ref) {
+    function resolve(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -29522,7 +29522,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve2(baseURI, relativeURI, options) {
+    function resolve(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -29749,7 +29749,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve: resolve2,
+      resolve,
       resolveComponent,
       equal,
       serialize,
@@ -32777,13 +32777,13 @@ function listMigrationFiles() {
   return fs6.readdirSync(migrationsDir).filter((f) => MIGRATION_FILE_RE.test(f)).sort();
 }
 function runOne(file) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve, reject) => {
     const child = spawn(process.execPath, [file], {
       stdio: "inherit",
       env: process.env
     });
     child.on("exit", (code) => {
-      if (code === 0) return resolve2();
+      if (code === 0) return resolve();
       reject(new Error(`Migration ${path7.basename(file)} exited with code ${code}`));
     });
     child.on("error", reject);
@@ -44906,7 +44906,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+        await new Promise((resolve) => setTimeout(resolve, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error2) {
@@ -44923,7 +44923,7 @@ var Protocol = class {
    */
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve, reject) => {
       const earlyReject = (error2) => {
         reject(error2);
       };
@@ -45001,7 +45001,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve2(parseResult.data);
+            resolve(parseResult.data);
           }
         } catch (error2) {
           reject(error2);
@@ -45262,12 +45262,12 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve2, interval);
+      const timeoutId = setTimeout(resolve, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -46367,7 +46367,7 @@ var McpServer = class {
     let task = createTaskResult.task;
     const pollInterval = task.pollInterval ?? 5e3;
     while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-      await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
       const updatedTask = await extra.taskStore.getTask(taskId);
       if (!updatedTask) {
         throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
@@ -47016,12 +47016,12 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve2) => {
+    return new Promise((resolve) => {
       const json = serializeMessage(message);
       if (this._stdout.write(json)) {
-        resolve2();
+        resolve();
       } else {
-        this._stdout.once("drain", resolve2);
+        this._stdout.once("drain", resolve);
       }
     });
   }
@@ -47029,6 +47029,7 @@ var StdioServerTransport = class {
 
 // src/tools/manage_knowledge.ts
 init_db();
+import * as os2 from "node:os";
 
 // src/hot_path.ts
 init_db();
@@ -47046,7 +47047,8 @@ async function insertRawMemory(params) {
     p_tag_id = null,
     d_tag = [],
     embedding = null,
-    external_uuid = null
+    external_uuid = null,
+    device_name = null
   } = params;
   const embeddingSql = embedding && embedding.length > 0 ? `[${embedding.join(",")}]` : null;
   const tagProcessed = p_tag_id !== null;
@@ -47056,13 +47058,15 @@ async function insertRawMemory(params) {
        subagent, subagent_model, subagent_role,
        role, message,
        p_tag_id, d_tag, embedding,
-       is_pinned, tag_processed, external_uuid
+       is_pinned, tag_processed, external_uuid,
+       device_name
      ) VALUES (
        $1, $2, $3,
        $4, $5, $6,
        $7, $8,
        $9, $10::text[], $11::halfvec,
-       $12, $13, $14
+       $12, $13, $14,
+       $15
      )
      ON CONFLICT (external_uuid) WHERE external_uuid IS NOT NULL
        DO NOTHING
@@ -47081,7 +47085,8 @@ async function insertRawMemory(params) {
       embeddingSql,
       is_pinned,
       tagProcessed,
-      external_uuid
+      external_uuid,
+      device_name
     ]
   );
   if (result.rows.length === 0) {
@@ -47388,7 +47393,7 @@ var safeJSON = (text) => {
 };
 
 // node_modules/openai/internal/utils/sleep.mjs
-var sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
 // node_modules/openai/version.mjs
 var VERSION = "6.34.0";
@@ -48467,8 +48472,8 @@ function addRequestID(value, response) {
 var _APIPromise_client;
 var APIPromise = class _APIPromise extends Promise {
   constructor(client2, responsePromise, parseResponse2 = defaultParseResponse) {
-    super((resolve2) => {
-      resolve2(null);
+    super((resolve) => {
+      resolve(null);
     });
     this.responsePromise = responsePromise;
     this.parseResponse = parseResponse2;
@@ -49116,12 +49121,12 @@ var EventStream = class {
     _EventStream_errored.set(this, false);
     _EventStream_aborted.set(this, false);
     _EventStream_catchingPromiseCreated.set(this, false);
-    __classPrivateFieldSet(this, _EventStream_connectedPromise, new Promise((resolve2, reject) => {
-      __classPrivateFieldSet(this, _EventStream_resolveConnectedPromise, resolve2, "f");
+    __classPrivateFieldSet(this, _EventStream_connectedPromise, new Promise((resolve, reject) => {
+      __classPrivateFieldSet(this, _EventStream_resolveConnectedPromise, resolve, "f");
       __classPrivateFieldSet(this, _EventStream_rejectConnectedPromise, reject, "f");
     }), "f");
-    __classPrivateFieldSet(this, _EventStream_endPromise, new Promise((resolve2, reject) => {
-      __classPrivateFieldSet(this, _EventStream_resolveEndPromise, resolve2, "f");
+    __classPrivateFieldSet(this, _EventStream_endPromise, new Promise((resolve, reject) => {
+      __classPrivateFieldSet(this, _EventStream_resolveEndPromise, resolve, "f");
       __classPrivateFieldSet(this, _EventStream_rejectEndPromise, reject, "f");
     }), "f");
     __classPrivateFieldGet(this, _EventStream_connectedPromise, "f").catch(() => {
@@ -49205,11 +49210,11 @@ var EventStream = class {
    *   const message = await stream.emitted('message') // rejects if the stream errors
    */
   emitted(event) {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve, reject) => {
       __classPrivateFieldSet(this, _EventStream_catchingPromiseCreated, true, "f");
       if (event !== "error")
         this.once("error", reject);
-      this.once(event, resolve2);
+      this.once(event, resolve);
     });
   }
   async done() {
@@ -50148,7 +50153,7 @@ var ChatCompletionStream = class _ChatCompletionStream extends AbstractChatCompl
           if (done) {
             return { value: void 0, done: true };
           }
-          return new Promise((resolve2, reject) => readQueue.push({ resolve: resolve2, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
+          return new Promise((resolve, reject) => readQueue.push({ resolve, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
         }
         const chunk = pushQueue.shift();
         return { value: chunk, done: false };
@@ -50980,7 +50985,7 @@ var AssistantStream = class extends EventStream {
           if (done) {
             return { value: void 0, done: true };
           }
-          return new Promise((resolve2, reject) => readQueue.push({ resolve: resolve2, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
+          return new Promise((resolve, reject) => readQueue.push({ resolve, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
         }
         const chunk = pushQueue.shift();
         return { value: chunk, done: false };
@@ -52929,7 +52934,7 @@ var ResponseStream = class _ResponseStream extends EventStream {
           if (done) {
             return { value: void 0, done: true };
           }
-          return new Promise((resolve2, reject) => readQueue.push({ resolve: resolve2, reject })).then((event2) => event2 ? { value: event2, done: false } : { value: void 0, done: true });
+          return new Promise((resolve, reject) => readQueue.push({ resolve, reject })).then((event2) => event2 ? { value: event2, done: false } : { value: void 0, done: true });
         }
         const event = pushQueue.shift();
         return { value: event, done: false };
@@ -55330,8 +55335,9 @@ function inferProvider(modelName) {
   return null;
 }
 var DEFAULTS = {
-  tagger: { provider: "google", model_name: "gemini-2.5-flash" },
-  librarian: { provider: "google", model_name: "gemini-2.5-flash" }
+  tagger: { provider: "xai", model_name: "grok-4-1-fast-non-reasoning" },
+  librarian: { provider: "xai", model_name: "grok-4-1-fast-non-reasoning" },
+  clusterer: { provider: "xai", model_name: "grok-4-1-fast-non-reasoning" }
 };
 function envEnvelope(role) {
   const upper = role.toUpperCase();
@@ -55357,7 +55363,8 @@ function envEnvelope(role) {
 }
 var ROLE_REGISTRY = {
   tagger: envEnvelope("tagger"),
-  librarian: envEnvelope("librarian")
+  librarian: envEnvelope("librarian"),
+  clusterer: envEnvelope("clusterer")
 };
 for (const [role, spec] of Object.entries(ROLE_REGISTRY)) {
   try {
@@ -55627,6 +55634,7 @@ function resolveAgentIdentity(server, args) {
 }
 
 // src/tools/manage_knowledge.ts
+var DEVICE_NAME = os2.hostname();
 function ok(payload) {
   return {
     content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
@@ -55791,7 +55799,8 @@ ${args.content}` : args.content;
         // 강제 기억은 archive 면제
         p_tag_id,
         d_tag,
-        embedding
+        embedding,
+        device_name: DEVICE_NAME
       });
       return ok({
         stored: true,
@@ -56094,6 +56103,7 @@ date_range \uC778\uC2DD \uD615\uC2DD:
 
 // src/briefing.ts
 init_db();
+import * as os3 from "node:os";
 var RECENT_CURRENT_LIMIT = 8;
 var RECENT_OTHERS_LIMIT = 4;
 var RECENT_MESSAGE_PREVIEW = 100;
@@ -56125,7 +56135,7 @@ async function collectBrief(opts = {}) {
   let recentOthers = [];
   if (currentPlatform) {
     const currentMsgs = await db.query(
-      `SELECT role, agent_platform, message, created_at
+      `SELECT role, agent_platform, device_name, message, created_at
          FROM memory
         WHERE user_id = $1
           AND is_active = TRUE
@@ -56137,7 +56147,7 @@ async function collectBrief(opts = {}) {
     );
     recentCurrent = currentMsgs.rows.reverse().map(rowToMsg);
     const othersMsgs = await db.query(
-      `SELECT role, agent_platform, message, created_at
+      `SELECT role, agent_platform, device_name, message, created_at
          FROM memory
         WHERE user_id = $1
           AND is_active = TRUE
@@ -56150,7 +56160,7 @@ async function collectBrief(opts = {}) {
     recentOthers = othersMsgs.rows.reverse().map(rowToMsg);
   } else {
     const msgs = await db.query(
-      `SELECT role, agent_platform, message, created_at
+      `SELECT role, agent_platform, device_name, message, created_at
          FROM memory
         WHERE user_id = $1
           AND is_active = TRUE
@@ -56180,6 +56190,7 @@ function rowToMsg(r) {
   return {
     role: r.role,
     agent_platform: r.agent_platform,
+    device_name: r.device_name ?? null,
     preview: String(r.message ?? "").slice(0, RECENT_MESSAGE_PREVIEW),
     created_at: r.created_at
   };
@@ -56188,7 +56199,7 @@ function formatBriefMarkdown(brief) {
   const lines = [];
   lines.push(`# Memory Briefing (user: ${brief.user_name})`);
   if (brief.current_platform) {
-    lines.push(`Current platform: \`${brief.current_platform}\``);
+    lines.push(`Current platform: \`${brief.current_platform} @ ${os3.hostname()}\``);
   }
   lines.push("");
   if (brief.core_profile) {
@@ -56234,7 +56245,8 @@ function formatBriefMarkdown(brief) {
 }
 function formatMsgLine(m, showPlatform) {
   const dt = m.created_at?.toISOString?.().slice(11, 16) ?? "";
-  const platformTag = showPlatform ? `${m.agent_platform} ` : "";
+  const device = m.device_name ? `@${m.device_name} ` : "";
+  const platformTag = showPlatform ? `${m.agent_platform} ${device}` : device;
   const truncated = m.preview.length >= RECENT_MESSAGE_PREVIEW ? "\u2026" : "";
   return `- [${dt} ${platformTag}${m.role}] ${m.preview}${truncated}`;
 }
@@ -56288,6 +56300,394 @@ agent_platform_filter=false.`,
 }
 
 // src/auto_save/save_message_tool.ts
+import * as os5 from "node:os";
+
+// src/auto_save/gemini_capture.ts
+import * as fs2 from "node:fs";
+import * as path3 from "node:path";
+import * as os4 from "node:os";
+import * as crypto2 from "node:crypto";
+var CLIENT_PLATFORM = "gemini-cli-mcp-client";
+var DEVICE_NAME2 = os4.hostname();
+var GEMINI_TMP_ROOT = path3.join(os4.homedir(), ".gemini", "tmp");
+var FLUSH_DEBOUNCE_MS = 200;
+var PARSE_RETRY_MS = 80;
+var POLL_INTERVAL_MS = 3e3;
+var _state = null;
+var _watchers = [];
+var _pollTimer = null;
+var _flushInProgress = false;
+var _flushPending = false;
+var _flushDebounceTimer = null;
+function extractShortId(filename) {
+  const m = filename.match(/^session-.+?-([0-9a-f]+)\.json$/);
+  return m ? m[1] : filename.replace(/\.json$/, "");
+}
+function deriveChatsDirCandidates(cwd) {
+  const cwdHash = crypto2.createHash("sha256").update(cwd).digest("hex");
+  const candidates = [
+    path3.join(GEMINI_TMP_ROOT, cwdHash, "chats"),
+    path3.join(GEMINI_TMP_ROOT, path3.basename(cwd), "chats")
+  ];
+  return candidates.filter((d) => fs2.existsSync(d));
+}
+async function readSessionFile(filePath) {
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const raw = fs2.readFileSync(filePath, "utf-8");
+      if (!raw.trim()) return null;
+      return JSON.parse(raw);
+    } catch {
+      if (attempt === 0) {
+        await new Promise((r) => setTimeout(r, PARSE_RETRY_MS));
+        continue;
+      }
+      return null;
+    }
+  }
+  return null;
+}
+function parseMessage(msg, fallbackId) {
+  let role;
+  if (msg.type === "user") role = "user";
+  else if (msg.type === "gemini") role = "assistant";
+  else return null;
+  let text = "";
+  const c = msg.content;
+  if (typeof c === "string") {
+    text = c;
+  } else if (Array.isArray(c)) {
+    for (const block of c) {
+      if (block && typeof block === "object" && typeof block.text === "string") {
+        text += (text ? "\n" : "") + block.text;
+      }
+    }
+  }
+  text = text.trim();
+  if (!text) return null;
+  if (text.startsWith("System:") || text === "Please continue.") return null;
+  const msgId = typeof msg.id === "string" && msg.id ? msg.id : fallbackId;
+  const agent_model = role === "assistant" && typeof msg.model === "string" ? msg.model : null;
+  return { msgId, role, message: text, agent_model };
+}
+async function flushDeltaForFile(filePath, fileState, contentSeen) {
+  return fileState.format === "jsonl" ? flushJsonlFile(filePath, fileState, contentSeen) : flushJsonFile(filePath, fileState, contentSeen);
+}
+async function flushJsonFile(filePath, fileState, contentSeen) {
+  const session = await readSessionFile(filePath);
+  if (!session || !Array.isArray(session.messages)) {
+    return { inserted: 0, skipped: 0, dedup: 0 };
+  }
+  const messages = session.messages;
+  if (messages.length <= fileState.cursor) {
+    return { inserted: 0, skipped: 0, dedup: 0 };
+  }
+  if (typeof session.sessionId === "string" && session.sessionId) {
+    fileState.sessionId = session.sessionId;
+  }
+  const userId = await getDefaultUserId();
+  let inserted = 0, skipped = 0, dedup = 0;
+  for (let i = fileState.cursor; i < messages.length; i++) {
+    const msg = messages[i];
+    const fallbackId = `${fileState.sessionId}-${i}`;
+    const parsed = parseMessage(msg, fallbackId);
+    if (!parsed) {
+      skipped++;
+      continue;
+    }
+    const ck = `${parsed.role}::${parsed.message}`;
+    if (contentSeen.has(ck)) {
+      dedup++;
+      continue;
+    }
+    contentSeen.add(ck);
+    const externalUuid = `gemini:${fileState.sessionId}:${parsed.msgId}`;
+    const agentModel = parsed.role === "user" ? null : parsed.agent_model ?? "unknown";
+    try {
+      const result = await insertRawMemory({
+        user_id: userId,
+        agent_platform: CLIENT_PLATFORM,
+        agent_model: agentModel,
+        role: parsed.role,
+        message: parsed.message,
+        external_uuid: externalUuid,
+        device_name: DEVICE_NAME2
+      });
+      if (result.inserted) inserted++;
+      else dedup++;
+    } catch (err2) {
+      console.error(`\u26A0\uFE0F [Gemini] insert failed at index ${i}:`, err2);
+      skipped++;
+    }
+  }
+  fileState.cursor = messages.length;
+  return { inserted, skipped, dedup };
+}
+async function flushJsonlFile(filePath, fileState, contentSeen) {
+  if (!fs2.existsSync(filePath)) return { inserted: 0, skipped: 0, dedup: 0 };
+  let stat;
+  try {
+    stat = fs2.statSync(filePath);
+  } catch {
+    return { inserted: 0, skipped: 0, dedup: 0 };
+  }
+  if (stat.size <= fileState.cursor) return { inserted: 0, skipped: 0, dedup: 0 };
+  const length = stat.size - fileState.cursor;
+  const fd = fs2.openSync(filePath, "r");
+  let raw;
+  try {
+    const buf = Buffer.alloc(length);
+    fs2.readSync(fd, buf, 0, length, fileState.cursor);
+    raw = buf.toString("utf-8");
+  } finally {
+    fs2.closeSync(fd);
+  }
+  const lastNl = raw.lastIndexOf("\n");
+  if (lastNl === -1) return { inserted: 0, skipped: 0, dedup: 0 };
+  const parsable = raw.slice(0, lastNl);
+  const advanceBy = Buffer.byteLength(parsable, "utf-8") + 1;
+  const newCursor = fileState.cursor + advanceBy;
+  const userId = await getDefaultUserId();
+  let inserted = 0, skipped = 0, dedup = 0;
+  let lineIdx = fileState.cursor === 0 ? 0 : -1;
+  for (const line of parsable.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      lineIdx++;
+      continue;
+    }
+    let obj;
+    try {
+      obj = JSON.parse(trimmed);
+    } catch {
+      lineIdx++;
+      continue;
+    }
+    if (lineIdx === 0 && typeof obj.sessionId === "string" && obj.sessionId) {
+      fileState.sessionId = obj.sessionId;
+      lineIdx++;
+      continue;
+    }
+    lineIdx++;
+    if (obj.$set !== void 0) continue;
+    const parsed = parseMessage(obj, `${fileState.sessionId}-${lineIdx}`);
+    if (!parsed) {
+      skipped++;
+      continue;
+    }
+    const ck = `${parsed.role}::${parsed.message}`;
+    if (contentSeen.has(ck)) {
+      dedup++;
+      continue;
+    }
+    contentSeen.add(ck);
+    const externalUuid = `gemini:${fileState.sessionId}:${parsed.msgId}`;
+    const agentModel = parsed.role === "user" ? null : parsed.agent_model ?? "unknown";
+    try {
+      const result = await insertRawMemory({
+        user_id: userId,
+        agent_platform: CLIENT_PLATFORM,
+        agent_model: agentModel,
+        role: parsed.role,
+        message: parsed.message,
+        external_uuid: externalUuid,
+        device_name: DEVICE_NAME2
+      });
+      if (result.inserted) inserted++;
+      else dedup++;
+    } catch (err2) {
+      console.error(`\u26A0\uFE0F [Gemini] jsonl insert failed:`, err2);
+      skipped++;
+    }
+  }
+  fileState.cursor = newCursor;
+  return { inserted, skipped, dedup };
+}
+function isCaptureArmed() {
+  return _state !== null && _state.chatsDirs.length > 0;
+}
+async function flushAllFiles() {
+  if (!_state) return { inserted: 0, skipped: 0, dedup: 0 };
+  let totalI = 0, totalS = 0, totalD = 0;
+  const contentSeen = /* @__PURE__ */ new Set();
+  for (const dir of _state.chatsDirs) {
+    if (!fs2.existsSync(dir)) continue;
+    let entries;
+    try {
+      entries = fs2.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      if (!entry.name.startsWith("session-")) continue;
+      if (!entry.name.endsWith(".json") && !entry.name.endsWith(".jsonl")) continue;
+      const filePath = path3.join(dir, entry.name);
+      let fileState = _state.files.get(filePath);
+      if (!fileState) {
+        const sessionId = extractShortId(entry.name);
+        const format = entry.name.endsWith(".jsonl") ? "jsonl" : "json";
+        fileState = { cursor: 0, format, sessionId };
+        _state.files.set(filePath, fileState);
+        console.error(`\u{1F4DD} [Gemini] new session detected: ${entry.name} (${format})`);
+      }
+      const r = await flushDeltaForFile(filePath, fileState, contentSeen);
+      totalI += r.inserted;
+      totalS += r.skipped;
+      totalD += r.dedup;
+    }
+  }
+  return { inserted: totalI, skipped: totalS, dedup: totalD };
+}
+async function flushWithMutex() {
+  if (_flushInProgress) {
+    _flushPending = true;
+    return;
+  }
+  _flushInProgress = true;
+  try {
+    const r = await flushAllFiles();
+    if (r.inserted > 0 || r.skipped > 0 || r.dedup > 0) {
+      console.error(`\u{1F4DD} [Gemini] live flush: inserted=${r.inserted}, dedup=${r.dedup}, skipped=${r.skipped}`);
+    }
+  } catch (err2) {
+    console.error("\u26A0\uFE0F [Gemini] live flush error:", err2);
+  } finally {
+    _flushInProgress = false;
+    if (_flushPending) {
+      _flushPending = false;
+      setImmediate(() => {
+        void flushWithMutex();
+      });
+    }
+  }
+}
+function scheduleFlush() {
+  if (_flushDebounceTimer) clearTimeout(_flushDebounceTimer);
+  _flushDebounceTimer = setTimeout(() => {
+    _flushDebounceTimer = null;
+    void flushWithMutex();
+  }, FLUSH_DEBOUNCE_MS);
+}
+function captureSessionStart(cwd) {
+  const chatsDirs = deriveChatsDirCandidates(cwd);
+  _state = { cwd, chatsDirs, files: /* @__PURE__ */ new Map() };
+  if (chatsDirs.length === 0) {
+    return;
+  }
+  let count = 0;
+  for (const dir of chatsDirs) {
+    let entries;
+    try {
+      entries = fs2.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      if (!entry.name.startsWith("session-")) continue;
+      if (!entry.name.endsWith(".json") && !entry.name.endsWith(".jsonl")) continue;
+      const filePath = path3.join(dir, entry.name);
+      const format = entry.name.endsWith(".jsonl") ? "jsonl" : "json";
+      const sessionId = extractShortId(entry.name);
+      let cursor = 0;
+      let realSessionId = sessionId;
+      if (format === "json") {
+        let session = null;
+        try {
+          session = JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+        } catch {
+        }
+        cursor = session && Array.isArray(session.messages) ? session.messages.length : 0;
+        if (session?.sessionId) realSessionId = session.sessionId;
+      } else {
+        try {
+          cursor = fs2.statSync(filePath).size;
+        } catch {
+        }
+        try {
+          const fd = fs2.openSync(filePath, "r");
+          const buf = Buffer.alloc(512);
+          const n = fs2.readSync(fd, buf, 0, 512, 0);
+          fs2.closeSync(fd);
+          const firstLine = buf.slice(0, n).toString("utf-8").split("\n")[0].trim();
+          const header = JSON.parse(firstLine);
+          if (typeof header.sessionId === "string" && header.sessionId) {
+            realSessionId = header.sessionId;
+          }
+        } catch {
+        }
+      }
+      _state.files.set(filePath, { cursor, format, sessionId: realSessionId });
+      count++;
+    }
+  }
+  console.error(
+    `\u{1F4DD} [Gemini] capture armed: ${count} session(s) across ${chatsDirs.length} chats dir(s)`
+  );
+  armDirWatchers();
+}
+function armDirWatchers() {
+  if (!_state) return;
+  if (_watchers.length > 0) return;
+  for (const dir of _state.chatsDirs) {
+    try {
+      const w = fs2.watch(dir, (_evt, filename) => {
+        if (filename && !filename.endsWith(".json") && !filename.endsWith(".jsonl")) return;
+        scheduleFlush();
+      });
+      _watchers.push(w);
+    } catch (err2) {
+      console.error(`\u26A0\uFE0F [Gemini] fs.watch ${dir} failed:`, err2);
+    }
+  }
+  if (_watchers.length > 0) {
+    console.error(`\u{1F4DD} [Gemini] dir watcher(s) armed: ${_watchers.length}`);
+  }
+  _pollTimer = setInterval(() => {
+    void flushWithMutex();
+  }, POLL_INTERVAL_MS);
+}
+function disarmDirWatchers() {
+  if (_flushDebounceTimer) {
+    clearTimeout(_flushDebounceTimer);
+    _flushDebounceTimer = null;
+  }
+  if (_pollTimer) {
+    clearInterval(_pollTimer);
+    _pollTimer = null;
+  }
+  for (const w of _watchers) {
+    try {
+      w.close();
+    } catch {
+    }
+  }
+  _watchers.length = 0;
+}
+async function captureSessionEnd() {
+  disarmDirWatchers();
+  const waitStart = Date.now();
+  while (_flushInProgress && Date.now() - waitStart < 2e3) {
+    await new Promise((r) => setTimeout(r, 50));
+  }
+  if (!_state || _state.chatsDirs.length === 0) {
+    return { inserted: 0, skipped: 0, error: "session not armed" };
+  }
+  _flushInProgress = true;
+  try {
+    const r = await flushAllFiles();
+    if (r.inserted > 0 || r.skipped > 0 || r.dedup > 0) {
+      console.error(`\u{1F4DD} [Gemini] final flush: inserted=${r.inserted}, dedup=${r.dedup}, skipped=${r.skipped}`);
+    }
+    return { inserted: r.inserted, skipped: r.skipped };
+  } finally {
+    _flushInProgress = false;
+  }
+}
+
+// src/auto_save/save_message_tool.ts
+var DEVICE_NAME3 = os5.hostname();
 function registerSaveMessage(server) {
   server.registerTool(
     "save_message",
@@ -56320,6 +56720,14 @@ subagent \uCEE8\uD14D\uC2A4\uD2B8\uB77C\uBA74 subagent=true + subagent_model + s
     async (args) => {
       const userId = await getDefaultUserId();
       const id = resolveAgentIdentity(server, args);
+      if (id.agent_platform === "gemini-cli-mcp-client" && isCaptureArmed()) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ stored: false, skipped: "passive capture active" }, null, 2)
+          }]
+        };
+      }
       const agentModel = args.role === "user" ? null : id.agent_model;
       const inserted = await insertRawMemory({
         user_id: userId,
@@ -56329,7 +56737,8 @@ subagent \uCEE8\uD14D\uC2A4\uD2B8\uB77C\uBA74 subagent=true + subagent_model + s
         subagent_model: id.subagent_model,
         subagent_role: id.subagent_role,
         role: args.role,
-        message: args.message
+        message: args.message,
+        device_name: DEVICE_NAME3
         // tag/embed NULL — Cold Path가 background 처리 (Hot Path latency 보장)
       });
       return {
@@ -56357,13 +56766,143 @@ function registerTools(server) {
 
 // src/cold_path/worker.ts
 init_db();
+
+// src/cold_path/dtag_promoter.ts
+init_db();
+function envInt(name, fallback) {
+  const raw = process.env[name];
+  if (!raw) return fallback;
+  const n = Number(raw);
+  return Number.isFinite(n) && n >= 1 ? n : fallback;
+}
+var CLUSTER_SYSTEM = `You are a keyword clustering assistant for a personal memory system.
+
+Given a list of d_tags (short hyphenated keywords) with their occurrence counts,
+group semantically similar tags that refer to the same project or topic.
+
+OUTPUT strict JSON array:
+[
+  { "canonical": "<best-slug>", "members": ["<tag1>", "<tag2>", ...] },
+  ...
+]
+
+Rules:
+- canonical must be one of the input tags (pick the most descriptive one) or a clean slug if none fit
+- canonical must be lowercase, hyphenated (e.g. "yt-signal-finder")
+- Only group tags that clearly refer to the same project/topic
+- Tags with no similar counterparts become their own single-member cluster
+- Do NOT merge unrelated topics just because they share one word`;
+async function clusterDTags(tags) {
+  if (tags.length === 0) return [];
+  const tagList = tags.map((t) => `${t.tag} (${t.cnt}x)`).join(", ");
+  const userPrompt = `Cluster these d_tags by project/topic:
+${tagList}`;
+  let raw;
+  try {
+    raw = await callRole("clusterer", {
+      system: CLUSTER_SYSTEM,
+      user: userPrompt,
+      responseFormat: "json",
+      maxTokens: 512
+    });
+  } catch (err2) {
+    console.error("\u26A0\uFE0F [DTagPromoter] clusterer call failed, falling back to no clustering:", err2);
+    return tags.map((t) => ({ canonical: t.tag, members: [t.tag], total: t.cnt }));
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) throw new Error("not an array");
+  } catch {
+    console.error("\u26A0\uFE0F [DTagPromoter] clusterer returned invalid JSON, falling back:", raw.slice(0, 200));
+    return tags.map((t) => ({ canonical: t.tag, members: [t.tag], total: t.cnt }));
+  }
+  const freqMap = new Map(tags.map((t) => [t.tag, t.cnt]));
+  return parsed.map((c) => {
+    const canonical = String(c.canonical || "").toLowerCase().trim().replace(/\s+/g, "-");
+    const members = Array.isArray(c.members) ? c.members.map((m) => String(m).toLowerCase().trim()).filter(Boolean) : [canonical];
+    const total = members.reduce((sum, m) => sum + (freqMap.get(m) ?? 0), 0);
+    return { canonical, members, total };
+  });
+}
+async function runDtagPromotion() {
+  const minCount = envInt("DTAG_PROMOTE_MIN_COUNT", 10);
+  const windowDays = envInt("DTAG_PROMOTE_WINDOW_DAYS", 30);
+  const userId = await getDefaultUserId();
+  const freqResult = await db.query(
+    `SELECT unnest(d_tag) AS tag, COUNT(*)::int AS cnt
+       FROM memory
+      WHERE user_id = $1
+        AND tag_processed = TRUE
+        AND is_active = TRUE
+        AND created_at >= NOW() - ($2 || ' days')::INTERVAL
+      GROUP BY tag
+     HAVING COUNT(*) >= 2
+      ORDER BY cnt DESC
+      LIMIT 50`,
+    [userId, String(windowDays)]
+  );
+  if (freqResult.rows.length === 0) return { promoted: [], retrotagged: 0 };
+  const tags = freqResult.rows.map((r) => ({
+    tag: String(r.tag).toLowerCase().trim(),
+    cnt: Number(r.cnt)
+  })).filter((t) => t.tag.length > 0);
+  const clusters = await clusterDTags(tags);
+  const toPromote = clusters.filter((c) => c.total >= minCount);
+  if (toPromote.length === 0) return { promoted: [], retrotagged: 0 };
+  const summary = { promoted: [], retrotagged: 0 };
+  for (const cluster of toPromote) {
+    if (!cluster.canonical) continue;
+    const upsert = await db.query(
+      `INSERT INTO project_tags (name)
+         VALUES ($1)
+         ON CONFLICT (name) DO NOTHING
+         RETURNING id`,
+      [cluster.canonical]
+    );
+    let pTagId;
+    if (upsert.rows.length > 0) {
+      pTagId = Number(upsert.rows[0].id);
+      summary.promoted.push(cluster.canonical);
+      console.error(`\u{1F3F7}\uFE0F [DTagPromoter] promoted "${cluster.canonical}" (total=${cluster.total}, members=${cluster.members.join(", ")})`);
+      invalidateCandidateCache();
+    } else {
+      const existing = await db.query(
+        `SELECT id FROM project_tags WHERE name = $1 LIMIT 1`,
+        [cluster.canonical]
+      );
+      if (existing.rows.length === 0) continue;
+      pTagId = Number(existing.rows[0].id);
+    }
+    for (const memberTag of cluster.members) {
+      const updated = await db.query(
+        `UPDATE memory
+            SET p_tag_id = $1, updated_at = NOW()
+          WHERE user_id = $2
+            AND tag_processed = TRUE
+            AND p_tag_id IS NULL
+            AND $3 = ANY(d_tag)
+         RETURNING id`,
+        [pTagId, userId, memberTag]
+      );
+      summary.retrotagged += updated.rows.length;
+    }
+    if (summary.retrotagged > 0) {
+      console.error(`\u{1F3F7}\uFE0F [DTagPromoter] retrotagged ${summary.retrotagged} rows with "${cluster.canonical}"`);
+    }
+  }
+  return summary;
+}
+
+// src/cold_path/worker.ts
 var intervalTimer = null;
 var warmupTimer = null;
 var running = false;
+var tickCount = 0;
 var DEFAULT_INTERVAL_SEC = 60;
 var DEFAULT_BATCH = 5;
 var DEFAULT_WARMUP_SEC = 30;
-function envInt(name, fallback) {
+function envInt2(name, fallback) {
   const raw = process.env[name];
   if (!raw) return fallback;
   const n = Number(raw);
@@ -56481,7 +57020,7 @@ async function recordError(client2, rowId, err2) {
 async function tick() {
   if (running) return 0;
   running = true;
-  const batchSize = envInt("COLD_PATH_BATCH_SIZE", DEFAULT_BATCH);
+  const batchSize = envInt2("COLD_PATH_BATCH_SIZE", DEFAULT_BATCH);
   const client2 = await db.getClient();
   try {
     await client2.query("BEGIN");
@@ -56515,19 +57054,35 @@ async function tick() {
     running = false;
   }
 }
+var DTAG_PROMOTE_EVERY_N_TICKS = 10;
+async function maybeRunPromotion() {
+  if (process.env.DTAG_PROMOTE_ENABLED === "false") return;
+  tickCount++;
+  if (tickCount % DTAG_PROMOTE_EVERY_N_TICKS !== 0) return;
+  try {
+    const result = await runDtagPromotion();
+    if (result.promoted.length > 0 || result.retrotagged > 0) {
+      console.error(`\u{1F3F7}\uFE0F [DTagPromoter] promoted=${result.promoted.length} tags, retrotagged=${result.retrotagged} rows`);
+    }
+  } catch (err2) {
+    console.error("\u26A0\uFE0F [DTagPromoter] promotion error (non-blocking):", err2);
+  }
+}
 function startColdPathWorker() {
   if (process.env.COLD_PATH_ENABLED === "false") {
     console.error("\u{1F535} [ColdPath] disabled (COLD_PATH_ENABLED=false)");
     return;
   }
-  const intervalSec = envInt("COLD_PATH_INTERVAL_SEC", DEFAULT_INTERVAL_SEC);
-  const warmupSec = envInt("COLD_PATH_WARMUP_SEC", DEFAULT_WARMUP_SEC);
+  const intervalSec = envInt2("COLD_PATH_INTERVAL_SEC", DEFAULT_INTERVAL_SEC);
+  const warmupSec = envInt2("COLD_PATH_WARMUP_SEC", DEFAULT_WARMUP_SEC);
   console.error(`\u{1F535} [ColdPath] starting \u2014 warmup ${warmupSec}s, interval ${intervalSec}s`);
   warmupTimer = setTimeout(() => {
     intervalTimer = setInterval(() => {
       tick().catch((err2) => console.error("\u274C [ColdPath] unhandled tick error:", err2));
+      maybeRunPromotion().catch((err2) => console.error("\u274C [DTagPromoter] unhandled error:", err2));
     }, intervalSec * 1e3);
     tick().catch((err2) => console.error("\u274C [ColdPath] unhandled first tick:", err2));
+    maybeRunPromotion().catch((err2) => console.error("\u274C [DTagPromoter] unhandled error:", err2));
   }, warmupSec * 1e3);
 }
 function stopColdPathWorker() {
@@ -56556,36 +57111,37 @@ async function drainColdPath(maxTicks = 12) {
 }
 
 // src/auto_save/jsonl_capture.ts
-import * as fs2 from "node:fs";
-import * as path3 from "node:path";
-import * as os2 from "node:os";
-var CLIENT_PLATFORM = "claude-code";
-var PROJECTS_ROOT = path3.join(os2.homedir(), ".claude", "projects");
-var FLUSH_DEBOUNCE_MS = 200;
-var _state = null;
+import * as fs3 from "node:fs";
+import * as path4 from "node:path";
+import * as os6 from "node:os";
+var CLIENT_PLATFORM2 = "claude-code";
+var DEVICE_NAME4 = os6.hostname();
+var PROJECTS_ROOT = path4.join(os6.homedir(), ".claude", "projects");
+var FLUSH_DEBOUNCE_MS2 = 200;
+var _state2 = null;
 var _watcher = null;
-var _flushInProgress = false;
-var _flushPending = false;
-var _flushDebounceTimer = null;
+var _flushInProgress2 = false;
+var _flushPending2 = false;
+var _flushDebounceTimer2 = null;
 function findProjectDir(cwd) {
   let subdirs;
   try {
-    subdirs = fs2.readdirSync(PROJECTS_ROOT, { withFileTypes: true });
+    subdirs = fs3.readdirSync(PROJECTS_ROOT, { withFileTypes: true });
   } catch {
     return null;
   }
   for (const subdir of subdirs) {
     if (!subdir.isDirectory()) continue;
-    const dirPath = path3.join(PROJECTS_ROOT, subdir.name);
+    const dirPath = path4.join(PROJECTS_ROOT, subdir.name);
     let files;
     try {
-      files = fs2.readdirSync(dirPath, { withFileTypes: true });
+      files = fs3.readdirSync(dirPath, { withFileTypes: true });
     } catch {
       continue;
     }
     const jsonlFile = files.find((f) => f.isFile() && f.name.endsWith(".jsonl"));
     if (!jsonlFile) continue;
-    const foundCwd = readCwdFromJsonl(path3.join(dirPath, jsonlFile.name));
+    const foundCwd = readCwdFromJsonl(path4.join(dirPath, jsonlFile.name));
     if (foundCwd === cwd) return dirPath;
   }
   return null;
@@ -56593,13 +57149,13 @@ function findProjectDir(cwd) {
 function readCwdFromJsonl(jsonlPath) {
   let fd;
   try {
-    fd = fs2.openSync(jsonlPath, "r");
+    fd = fs3.openSync(jsonlPath, "r");
   } catch {
     return null;
   }
   try {
     const buf = Buffer.alloc(2048);
-    const bytesRead = fs2.readSync(fd, buf, 0, 2048, 0);
+    const bytesRead = fs3.readSync(fd, buf, 0, 2048, 0);
     const raw = buf.slice(0, bytesRead).toString("utf-8");
     for (const line of raw.split("\n")) {
       if (!line.trim()) continue;
@@ -56611,35 +57167,35 @@ function readCwdFromJsonl(jsonlPath) {
     }
     return null;
   } finally {
-    fs2.closeSync(fd);
+    fs3.closeSync(fd);
   }
 }
-function captureSessionStart(cwd) {
-  _state = { cwd, projectDir: null, files: /* @__PURE__ */ new Map() };
+function captureSessionStart2(cwd) {
+  _state2 = { cwd, projectDir: null, files: /* @__PURE__ */ new Map() };
   const projectDir = findProjectDir(cwd);
   if (!projectDir) {
     return;
   }
-  _state.projectDir = projectDir;
+  _state2.projectDir = projectDir;
   let entries;
   try {
-    entries = fs2.readdirSync(projectDir, { withFileTypes: true });
+    entries = fs3.readdirSync(projectDir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".jsonl")) continue;
-    const jsonlPath = path3.join(projectDir, entry.name);
+    const jsonlPath = path4.join(projectDir, entry.name);
     let stat;
     try {
-      stat = fs2.statSync(jsonlPath);
+      stat = fs3.statSync(jsonlPath);
     } catch {
       continue;
     }
     const sessionId = entry.name.replace(/\.jsonl$/, "");
-    _state.files.set(jsonlPath, { cursorBytes: stat.size, sessionId });
+    _state2.files.set(jsonlPath, { cursorBytes: stat.size, sessionId, contentSeen: /* @__PURE__ */ new Set() });
   }
-  console.error(`\u{1F4DD} [JSONL] capture armed: ${_state.files.size} jsonl(s) in ${path3.basename(projectDir)}/`);
+  console.error(`\u{1F4DD} [JSONL] capture armed: ${_state2.files.size} jsonl(s) in ${path4.basename(projectDir)}/`);
   armDirWatcher();
 }
 function parseEntry(line) {
@@ -56678,24 +57234,24 @@ function parseEntry(line) {
     agent_model
   };
 }
-async function flushDeltaForFile(jsonlPath, fileState) {
-  if (!fs2.existsSync(jsonlPath)) return { inserted: 0, skipped: 0, dedup: 0 };
+async function flushDeltaForFile2(jsonlPath, fileState) {
+  if (!fs3.existsSync(jsonlPath)) return { inserted: 0, skipped: 0, dedup: 0 };
   let stat;
   try {
-    stat = fs2.statSync(jsonlPath);
+    stat = fs3.statSync(jsonlPath);
   } catch {
     return { inserted: 0, skipped: 0, dedup: 0 };
   }
   if (stat.size <= fileState.cursorBytes) return { inserted: 0, skipped: 0, dedup: 0 };
   const length = stat.size - fileState.cursorBytes;
-  const fd = fs2.openSync(jsonlPath, "r");
+  const fd = fs3.openSync(jsonlPath, "r");
   let raw;
   try {
     const buf = Buffer.alloc(length);
-    fs2.readSync(fd, buf, 0, length, fileState.cursorBytes);
+    fs3.readSync(fd, buf, 0, length, fileState.cursorBytes);
     raw = buf.toString("utf-8");
   } finally {
-    fs2.closeSync(fd);
+    fs3.closeSync(fd);
   }
   const lastNl = raw.lastIndexOf("\n");
   if (lastNl === -1) return { inserted: 0, skipped: 0, dedup: 0 };
@@ -56713,16 +57269,23 @@ async function flushDeltaForFile(jsonlPath, fileState) {
       skipped++;
       continue;
     }
+    const ck = `${parsed.role}::${parsed.message}`;
+    if (fileState.contentSeen.has(ck)) {
+      dedup++;
+      continue;
+    }
+    fileState.contentSeen.add(ck);
     const externalUuid = `claude-code:${fileState.sessionId}:${parsed.uuid}`;
     const agentModel = parsed.role === "user" ? null : parsed.agent_model ?? "unknown";
     try {
       const result = await insertRawMemory({
         user_id: userId,
-        agent_platform: CLIENT_PLATFORM,
+        agent_platform: CLIENT_PLATFORM2,
         agent_model: agentModel,
         role: parsed.role,
         message: parsed.message,
-        external_uuid: externalUuid
+        external_uuid: externalUuid,
+        device_name: DEVICE_NAME4
       });
       if (result.inserted) inserted++;
       else dedup++;
@@ -56734,71 +57297,71 @@ async function flushDeltaForFile(jsonlPath, fileState) {
   fileState.cursorBytes = newCursor;
   return { inserted, skipped, dedup };
 }
-async function flushAllFiles() {
-  if (!_state || !_state.projectDir) return { inserted: 0, skipped: 0, dedup: 0 };
-  const projectDir = _state.projectDir;
-  if (!fs2.existsSync(projectDir)) return { inserted: 0, skipped: 0, dedup: 0 };
+async function flushAllFiles2() {
+  if (!_state2 || !_state2.projectDir) return { inserted: 0, skipped: 0, dedup: 0 };
+  const projectDir = _state2.projectDir;
+  if (!fs3.existsSync(projectDir)) return { inserted: 0, skipped: 0, dedup: 0 };
   let entries;
   try {
-    entries = fs2.readdirSync(projectDir, { withFileTypes: true });
+    entries = fs3.readdirSync(projectDir, { withFileTypes: true });
   } catch {
     return { inserted: 0, skipped: 0, dedup: 0 };
   }
   let totalI = 0, totalS = 0, totalD = 0;
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".jsonl")) continue;
-    const jsonlPath = path3.join(projectDir, entry.name);
-    let fileState = _state.files.get(jsonlPath);
+    const jsonlPath = path4.join(projectDir, entry.name);
+    let fileState = _state2.files.get(jsonlPath);
     if (!fileState) {
       const sessionId = entry.name.replace(/\.jsonl$/, "");
-      fileState = { cursorBytes: 0, sessionId };
-      _state.files.set(jsonlPath, fileState);
+      fileState = { cursorBytes: 0, sessionId, contentSeen: /* @__PURE__ */ new Set() };
+      _state2.files.set(jsonlPath, fileState);
       console.error(`\u{1F4DD} [JSONL] new session detected: ${entry.name}`);
     }
-    const r = await flushDeltaForFile(jsonlPath, fileState);
+    const r = await flushDeltaForFile2(jsonlPath, fileState);
     totalI += r.inserted;
     totalS += r.skipped;
     totalD += r.dedup;
   }
   return { inserted: totalI, skipped: totalS, dedup: totalD };
 }
-async function flushWithMutex() {
-  if (_flushInProgress) {
-    _flushPending = true;
+async function flushWithMutex2() {
+  if (_flushInProgress2) {
+    _flushPending2 = true;
     return;
   }
-  _flushInProgress = true;
+  _flushInProgress2 = true;
   try {
-    const r = await flushAllFiles();
+    const r = await flushAllFiles2();
     if (r.inserted > 0 || r.skipped > 0 || r.dedup > 0) {
       console.error(`\u{1F4DD} [JSONL] live flush: inserted=${r.inserted}, dedup=${r.dedup}, skipped=${r.skipped}`);
     }
   } catch (err2) {
     console.error("\u26A0\uFE0F [JSONL] live flush error:", err2);
   } finally {
-    _flushInProgress = false;
-    if (_flushPending) {
-      _flushPending = false;
+    _flushInProgress2 = false;
+    if (_flushPending2) {
+      _flushPending2 = false;
       setImmediate(() => {
-        void flushWithMutex();
+        void flushWithMutex2();
       });
     }
   }
 }
-function scheduleFlush() {
-  if (_flushDebounceTimer) clearTimeout(_flushDebounceTimer);
-  _flushDebounceTimer = setTimeout(() => {
-    _flushDebounceTimer = null;
-    void flushWithMutex();
-  }, FLUSH_DEBOUNCE_MS);
+function scheduleFlush2() {
+  if (_flushDebounceTimer2) clearTimeout(_flushDebounceTimer2);
+  _flushDebounceTimer2 = setTimeout(() => {
+    _flushDebounceTimer2 = null;
+    void flushWithMutex2();
+  }, FLUSH_DEBOUNCE_MS2);
 }
 function armDirWatcher() {
-  if (!_state || !_state.projectDir) return;
+  if (!_state2 || !_state2.projectDir) return;
   if (_watcher) return;
   try {
-    _watcher = fs2.watch(_state.projectDir, (_eventType, filename) => {
+    _watcher = fs3.watch(_state2.projectDir, (_eventType, filename) => {
       if (filename && !filename.endsWith(".jsonl")) return;
-      scheduleFlush();
+      scheduleFlush2();
     });
     console.error(`\u{1F4DD} [JSONL] dir watcher armed`);
   } catch (err2) {
@@ -56806,9 +57369,9 @@ function armDirWatcher() {
   }
 }
 function disarmDirWatcher() {
-  if (_flushDebounceTimer) {
-    clearTimeout(_flushDebounceTimer);
-    _flushDebounceTimer = null;
+  if (_flushDebounceTimer2) {
+    clearTimeout(_flushDebounceTimer2);
+    _flushDebounceTimer2 = null;
   }
   if (_watcher) {
     try {
@@ -56818,85 +57381,88 @@ function disarmDirWatcher() {
     _watcher = null;
   }
 }
-async function captureSessionEnd() {
+async function captureSessionEnd2() {
   disarmDirWatcher();
   const waitStart = Date.now();
-  while (_flushInProgress && Date.now() - waitStart < 2e3) {
+  while (_flushInProgress2 && Date.now() - waitStart < 2e3) {
     await new Promise((r) => setTimeout(r, 50));
   }
-  if (!_state || !_state.projectDir) {
+  if (!_state2 || !_state2.projectDir) {
     return { inserted: 0, skipped: 0, error: "session not armed" };
   }
-  _flushInProgress = true;
+  _flushInProgress2 = true;
   try {
-    const r = await flushAllFiles();
+    const r = await flushAllFiles2();
     if (r.inserted > 0 || r.skipped > 0 || r.dedup > 0) {
       console.error(`\u{1F4DD} [JSONL] final flush: inserted=${r.inserted}, dedup=${r.dedup}, skipped=${r.skipped}`);
     }
     return { inserted: r.inserted, skipped: r.skipped };
   } finally {
-    _flushInProgress = false;
+    _flushInProgress2 = false;
   }
 }
 
 // src/auto_save/codex_capture.ts
-import * as fs3 from "node:fs";
-import * as path4 from "node:path";
-import * as os3 from "node:os";
-var CLIENT_PLATFORM2 = "codex-mcp-client";
-var SESSIONS_ROOT = path4.join(os3.homedir(), ".codex", "sessions");
-var FLUSH_DEBOUNCE_MS2 = 200;
-var _state2 = null;
-var _watcher2 = null;
-var _flushInProgress2 = false;
-var _flushPending2 = false;
-var _flushDebounceTimer2 = null;
-function extractSessionId(filename) {
-  const m = filename.match(/^rollout-.+?-([0-9a-f-]{36})\.jsonl$/);
-  return m ? m[1] : null;
-}
-function probeSessionMeta(filePath) {
-  let fd;
-  try {
-    fd = fs3.openSync(filePath, "r");
-  } catch {
-    return null;
+import * as fs4 from "node:fs";
+import * as path5 from "node:path";
+import * as os7 from "node:os";
+import { spawnSync } from "node:child_process";
+var DEVICE_NAME5 = os7.hostname();
+var SESSIONS_ROOT = path5.join(os7.homedir(), ".codex", "sessions");
+var STATE_DB = path5.join(os7.homedir(), ".codex", "state_5.sqlite");
+var FLUSH_DEBOUNCE_MS3 = 200;
+var POLL_INTERVAL_MS2 = 3e3;
+function sourceToPlatform(source) {
+  switch (source) {
+    case "cli":
+      return "codex-cli";
+    case "vscode":
+      return "codex-desktop";
+    case "mcp":
+      return "codex-mcp";
+    case "exec":
+      return "codex-exec";
+    default:
+      return "codex-mcp-client";
   }
+}
+function lookupPlatform(sessionId) {
   try {
-    const buf = Buffer.alloc(8192);
-    const n = fs3.readSync(fd, buf, 0, 8192, 0);
-    if (n === 0) return null;
-    const slice = buf.slice(0, n).toString("utf-8");
-    const nl = slice.indexOf("\n");
-    if (nl === -1) return null;
-    const entry = JSON.parse(slice.slice(0, nl));
-    if (entry.type !== "session_meta") return null;
-    const sid = entry.payload?.id;
-    const cwd = entry.payload?.cwd;
-    if (typeof sid !== "string" || typeof cwd !== "string") return null;
-    return { sessionId: sid, cwd };
+    const res = spawnSync(
+      "sqlite3",
+      [STATE_DB, `SELECT source FROM threads WHERE id='${sessionId}' LIMIT 1;`],
+      { encoding: "utf-8", timeout: 500 }
+    );
+    const source = (res.stdout ?? "").trim();
+    if (source) return sourceToPlatform(source);
   } catch {
-    return null;
-  } finally {
-    try {
-      fs3.closeSync(fd);
-    } catch {
-    }
   }
+  return "codex-mcp-client";
+}
+var _state3 = null;
+var SERVER_START_MS = Date.now();
+var _watcher2 = null;
+var _pollTimer2 = null;
+var _flushInProgress3 = false;
+var _flushPending3 = false;
+var _flushDebounceTimer3 = null;
+function extractSessionId(filename) {
+  const m = filename.match(/^rollout-.+?-([0-9a-f-]{36})\.jsonl$/);
+  return m ? m[1] : null;
 }
 function* walkRollouts(root) {
-  if (!fs3.existsSync(root)) return;
+  if (!fs4.existsSync(root)) return;
   const stack = [root];
   while (stack.length) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = fs3.readdirSync(dir, { withFileTypes: true });
+      entries = fs4.readdirSync(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const e of entries) {
-      const p = path4.join(dir, e.name);
+      const p = path5.join(dir, e.name);
       if (e.isDirectory()) {
         stack.push(p);
       } else if (e.isFile() && e.name.startsWith("rollout-") && e.name.endsWith(".jsonl")) {
@@ -56905,43 +57471,34 @@ function* walkRollouts(root) {
     }
   }
 }
-function captureSessionStart2(cwd) {
-  const cwdNormalized = path4.resolve(cwd);
-  const rootExists = fs3.existsSync(SESSIONS_ROOT);
-  _state2 = {
-    cwd,
-    cwdNormalized,
+function captureSessionStart3(_cwd) {
+  const rootExists = fs4.existsSync(SESSIONS_ROOT);
+  _state3 = {
     rootExists,
     files: /* @__PURE__ */ new Map()
   };
   if (!rootExists) {
     return;
   }
-  let count = 0, matched = 0;
+  let count = 0;
   for (const filePath of walkRollouts(SESSIONS_ROOT)) {
     let stat;
     try {
-      stat = fs3.statSync(filePath);
+      stat = fs4.statSync(filePath);
     } catch {
       continue;
     }
-    const sessionId = extractSessionId(path4.basename(filePath));
+    const sessionId = extractSessionId(path5.basename(filePath));
     if (!sessionId) continue;
-    const meta = probeSessionMeta(filePath);
-    let cwdMatched = null;
-    if (meta) {
-      cwdMatched = path4.resolve(meta.cwd) === cwdNormalized;
-    }
-    _state2.files.set(filePath, {
+    _state3.files.set(filePath, {
       cursorBytes: stat.size,
       sessionId,
-      cwdMatched,
+      agentPlatform: lookupPlatform(sessionId),
       currentModel: null
     });
     count++;
-    if (cwdMatched) matched++;
   }
-  console.error(`\u{1F4DD} [Codex] capture armed: ${count} rollout(s), ${matched} cwd-matched`);
+  console.error(`\u{1F4DD} [Codex] capture armed: ${count} rollout(s)`);
   armDirWatcher2();
 }
 function parseEntry2(line, byteOffset) {
@@ -56965,6 +57522,9 @@ function parseEntry2(line, byteOffset) {
   }
   const message = typeof payload.message === "string" ? payload.message.trim() : "";
   if (!message) return null;
+  if (message.startsWith("[external_agent_tool_call:") || message.startsWith("[external_agent_tool_call_response:")) {
+    return null;
+  }
   return { byteOffset, role, message };
 }
 function extractModelFromTurnContext(line) {
@@ -56977,35 +57537,24 @@ function extractModelFromTurnContext(line) {
     return null;
   }
 }
-function applySessionMetaIfPresent(line, fileState, cwdNormalized) {
-  if (fileState.cwdMatched !== null) return;
-  try {
-    const entry = JSON.parse(line);
-    if (entry.type !== "session_meta") return;
-    const cwd = entry.payload?.cwd;
-    if (typeof cwd !== "string") return;
-    fileState.cwdMatched = path4.resolve(cwd) === cwdNormalized;
-  } catch {
-  }
-}
-async function flushDeltaForFile2(filePath, fileState, cwdNormalized) {
-  if (!fs3.existsSync(filePath)) return { inserted: 0, skipped: 0, dedup: 0 };
+async function flushDeltaForFile3(filePath, fileState) {
+  if (!fs4.existsSync(filePath)) return { inserted: 0, skipped: 0, dedup: 0 };
   let stat;
   try {
-    stat = fs3.statSync(filePath);
+    stat = fs4.statSync(filePath);
   } catch {
     return { inserted: 0, skipped: 0, dedup: 0 };
   }
   if (stat.size <= fileState.cursorBytes) return { inserted: 0, skipped: 0, dedup: 0 };
   const length = stat.size - fileState.cursorBytes;
-  const fd = fs3.openSync(filePath, "r");
+  const fd = fs4.openSync(filePath, "r");
   let raw;
   try {
     const buf = Buffer.alloc(length);
-    fs3.readSync(fd, buf, 0, length, fileState.cursorBytes);
+    fs4.readSync(fd, buf, 0, length, fileState.cursorBytes);
     raw = buf.toString("utf-8");
   } finally {
-    fs3.closeSync(fd);
+    fs4.closeSync(fd);
   }
   const lastNl = raw.lastIndexOf("\n");
   if (lastNl === -1) return { inserted: 0, skipped: 0, dedup: 0 };
@@ -57023,17 +57572,12 @@ async function flushDeltaForFile2(filePath, fileState, cwdNormalized) {
       lineStartInRaw += Buffer.byteLength(line, "utf-8") + 1;
       continue;
     }
-    applySessionMetaIfPresent(trimmed, fileState, cwdNormalized);
     const m = extractModelFromTurnContext(trimmed);
     if (m !== null) {
       fileState.currentModel = m;
       lineStartInRaw += Buffer.byteLength(line, "utf-8") + 1;
       continue;
     }
-    if (fileState.cwdMatched === false) {
-      lineStartInRaw += Buffer.byteLength(line, "utf-8") + 1;
-      continue;
-    }
     const byteOffset = startBase + lineStartInRaw;
     const parsed = parseEntry2(trimmed, byteOffset);
     if (!parsed) {
@@ -57041,21 +57585,17 @@ async function flushDeltaForFile2(filePath, fileState, cwdNormalized) {
       lineStartInRaw += Buffer.byteLength(line, "utf-8") + 1;
       continue;
     }
-    if (fileState.cwdMatched !== true) {
-      skipped++;
-      lineStartInRaw += Buffer.byteLength(line, "utf-8") + 1;
-      continue;
-    }
     const externalUuid = `codex:${fileState.sessionId}:${parsed.byteOffset}`;
     const agentModel = parsed.role === "user" ? null : fileState.currentModel ?? "unknown";
     try {
       const result = await insertRawMemory({
         user_id: userId,
-        agent_platform: CLIENT_PLATFORM2,
+        agent_platform: fileState.agentPlatform,
         agent_model: agentModel,
         role: parsed.role,
         message: parsed.message,
-        external_uuid: externalUuid
+        external_uuid: externalUuid,
+        device_name: DEVICE_NAME5
       });
       if (result.inserted) inserted++;
       else dedup++;
@@ -57068,247 +57608,42 @@ async function flushDeltaForFile2(filePath, fileState, cwdNormalized) {
   fileState.cursorBytes = newCursor;
   return { inserted, skipped, dedup };
 }
-async function flushAllFiles2() {
-  if (!_state2 || !_state2.rootExists) return { inserted: 0, skipped: 0, dedup: 0 };
-  const cwdNormalized = _state2.cwdNormalized;
+async function flushAllFiles3() {
+  if (!_state3 || !_state3.rootExists) return { inserted: 0, skipped: 0, dedup: 0 };
   let totalI = 0, totalS = 0, totalD = 0;
   for (const filePath of walkRollouts(SESSIONS_ROOT)) {
-    let fileState = _state2.files.get(filePath);
+    let fileState = _state3.files.get(filePath);
     if (!fileState) {
-      const sessionId = extractSessionId(path4.basename(filePath));
+      const sessionId = extractSessionId(path5.basename(filePath));
       if (!sessionId) continue;
+      let stat = null;
+      try {
+        stat = fs4.statSync(filePath);
+      } catch {
+      }
+      const fileBirthMs = stat ? stat.birthtimeMs || stat.ctimeMs : SERVER_START_MS;
+      const isPreExisting = fileBirthMs < SERVER_START_MS - 5e3;
+      const initialCursor = isPreExisting ? stat?.size ?? 0 : 0;
+      if (isPreExisting) {
+        console.error(`\u{1F4DD} [Codex] pre-existing rollout skipped (cursor=${initialCursor}): ${path5.basename(filePath)}`);
+      } else {
+        console.error(`\u{1F4DD} [Codex] new rollout detected: ${path5.basename(filePath)}`);
+      }
       fileState = {
-        cursorBytes: 0,
+        cursorBytes: initialCursor,
         sessionId,
-        cwdMatched: null,
+        agentPlatform: lookupPlatform(sessionId),
         currentModel: null
       };
-      _state2.files.set(filePath, fileState);
-      console.error(`\u{1F4DD} [Codex] new rollout detected: ${path4.basename(filePath)}`);
+      _state3.files.set(filePath, fileState);
     }
-    const r = await flushDeltaForFile2(filePath, fileState, cwdNormalized);
+    const r = await flushDeltaForFile3(filePath, fileState);
     totalI += r.inserted;
     totalS += r.skipped;
     totalD += r.dedup;
   }
   return { inserted: totalI, skipped: totalS, dedup: totalD };
 }
-async function flushWithMutex2() {
-  if (_flushInProgress2) {
-    _flushPending2 = true;
-    return;
-  }
-  _flushInProgress2 = true;
-  try {
-    const r = await flushAllFiles2();
-    if (r.inserted > 0 || r.skipped > 0 || r.dedup > 0) {
-      console.error(`\u{1F4DD} [Codex] live flush: inserted=${r.inserted}, dedup=${r.dedup}, skipped=${r.skipped}`);
-    }
-  } catch (err2) {
-    console.error("\u26A0\uFE0F [Codex] live flush error:", err2);
-  } finally {
-    _flushInProgress2 = false;
-    if (_flushPending2) {
-      _flushPending2 = false;
-      setImmediate(() => {
-        void flushWithMutex2();
-      });
-    }
-  }
-}
-function scheduleFlush2() {
-  if (_flushDebounceTimer2) clearTimeout(_flushDebounceTimer2);
-  _flushDebounceTimer2 = setTimeout(() => {
-    _flushDebounceTimer2 = null;
-    void flushWithMutex2();
-  }, FLUSH_DEBOUNCE_MS2);
-}
-function armDirWatcher2() {
-  if (!_state2 || !_state2.rootExists) return;
-  if (_watcher2) return;
-  try {
-    _watcher2 = fs3.watch(SESSIONS_ROOT, { recursive: true }, (_evt, filename) => {
-      if (!filename) return;
-      const base = path4.basename(filename);
-      if (!base.startsWith("rollout-") || !base.endsWith(".jsonl")) return;
-      scheduleFlush2();
-    });
-    console.error(`\u{1F4DD} [Codex] dir watcher armed (recursive)`);
-  } catch (err2) {
-    console.error("\u26A0\uFE0F [Codex] fs.watch failed (shutdown-only flush \uD3F4\uBC31):", err2);
-  }
-}
-function disarmDirWatcher2() {
-  if (_flushDebounceTimer2) {
-    clearTimeout(_flushDebounceTimer2);
-    _flushDebounceTimer2 = null;
-  }
-  if (_watcher2) {
-    try {
-      _watcher2.close();
-    } catch {
-    }
-    _watcher2 = null;
-  }
-}
-async function captureSessionEnd2() {
-  disarmDirWatcher2();
-  const waitStart = Date.now();
-  while (_flushInProgress2 && Date.now() - waitStart < 2e3) {
-    await new Promise((r) => setTimeout(r, 50));
-  }
-  if (!_state2 || !_state2.rootExists) {
-    return { inserted: 0, skipped: 0, error: "session not armed" };
-  }
-  _flushInProgress2 = true;
-  try {
-    const r = await flushAllFiles2();
-    if (r.inserted > 0 || r.skipped > 0 || r.dedup > 0) {
-      console.error(`\u{1F4DD} [Codex] final flush: inserted=${r.inserted}, dedup=${r.dedup}, skipped=${r.skipped}`);
-    }
-    return { inserted: r.inserted, skipped: r.skipped };
-  } finally {
-    _flushInProgress2 = false;
-  }
-}
-
-// src/auto_save/gemini_capture.ts
-import * as fs4 from "node:fs";
-import * as path5 from "node:path";
-import * as os4 from "node:os";
-import * as crypto2 from "node:crypto";
-var CLIENT_PLATFORM3 = "gemini-cli-mcp-client";
-var GEMINI_TMP_ROOT = path5.join(os4.homedir(), ".gemini", "tmp");
-var FLUSH_DEBOUNCE_MS3 = 200;
-var PARSE_RETRY_MS = 80;
-var _state3 = null;
-var _watchers = [];
-var _flushInProgress3 = false;
-var _flushPending3 = false;
-var _flushDebounceTimer3 = null;
-function extractShortId(filename) {
-  const m = filename.match(/^session-.+?-([0-9a-f]+)\.json$/);
-  return m ? m[1] : filename.replace(/\.json$/, "");
-}
-function deriveChatsDirCandidates(cwd) {
-  const cwdHash = crypto2.createHash("sha256").update(cwd).digest("hex");
-  const candidates = [
-    path5.join(GEMINI_TMP_ROOT, cwdHash, "chats"),
-    path5.join(GEMINI_TMP_ROOT, path5.basename(cwd), "chats")
-  ];
-  return candidates.filter((d) => fs4.existsSync(d));
-}
-async function readSessionFile(filePath) {
-  for (let attempt = 0; attempt < 2; attempt++) {
-    try {
-      const raw = fs4.readFileSync(filePath, "utf-8");
-      if (!raw.trim()) return null;
-      return JSON.parse(raw);
-    } catch {
-      if (attempt === 0) {
-        await new Promise((r) => setTimeout(r, PARSE_RETRY_MS));
-        continue;
-      }
-      return null;
-    }
-  }
-  return null;
-}
-function parseMessage(msg, fallbackId) {
-  let role;
-  if (msg.type === "user") role = "user";
-  else if (msg.type === "gemini") role = "assistant";
-  else return null;
-  let text = "";
-  const c = msg.content;
-  if (typeof c === "string") {
-    text = c;
-  } else if (Array.isArray(c)) {
-    for (const block of c) {
-      if (block && typeof block === "object" && typeof block.text === "string") {
-        text += (text ? "\n" : "") + block.text;
-      }
-    }
-  }
-  text = text.trim();
-  if (!text) return null;
-  const msgId = typeof msg.id === "string" && msg.id ? msg.id : fallbackId;
-  const agent_model = role === "assistant" && typeof msg.model === "string" ? msg.model : null;
-  return { msgId, role, message: text, agent_model };
-}
-async function flushDeltaForFile3(filePath, fileState) {
-  const session = await readSessionFile(filePath);
-  if (!session || !Array.isArray(session.messages)) {
-    return { inserted: 0, skipped: 0, dedup: 0 };
-  }
-  const messages = session.messages;
-  if (messages.length <= fileState.cursorIndex) {
-    return { inserted: 0, skipped: 0, dedup: 0 };
-  }
-  if (typeof session.sessionId === "string" && session.sessionId) {
-    fileState.sessionId = session.sessionId;
-  }
-  const userId = await getDefaultUserId();
-  let inserted = 0, skipped = 0, dedup = 0;
-  for (let i = fileState.cursorIndex; i < messages.length; i++) {
-    const msg = messages[i];
-    const fallbackId = `${fileState.sessionId}-${i}`;
-    const parsed = parseMessage(msg, fallbackId);
-    if (!parsed) {
-      skipped++;
-      continue;
-    }
-    const externalUuid = `gemini:${fileState.sessionId}:${parsed.msgId}`;
-    const agentModel = parsed.role === "user" ? null : parsed.agent_model ?? "unknown";
-    try {
-      const result = await insertRawMemory({
-        user_id: userId,
-        agent_platform: CLIENT_PLATFORM3,
-        agent_model: agentModel,
-        role: parsed.role,
-        message: parsed.message,
-        external_uuid: externalUuid
-      });
-      if (result.inserted) inserted++;
-      else dedup++;
-    } catch (err2) {
-      console.error(`\u26A0\uFE0F [Gemini] insert failed at index ${i}:`, err2);
-      skipped++;
-    }
-  }
-  fileState.cursorIndex = messages.length;
-  return { inserted, skipped, dedup };
-}
-async function flushAllFiles3() {
-  if (!_state3) return { inserted: 0, skipped: 0, dedup: 0 };
-  let totalI = 0, totalS = 0, totalD = 0;
-  for (const dir of _state3.chatsDirs) {
-    if (!fs4.existsSync(dir)) continue;
-    let entries;
-    try {
-      entries = fs4.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-      if (!entry.name.startsWith("session-")) continue;
-      const filePath = path5.join(dir, entry.name);
-      let fileState = _state3.files.get(filePath);
-      if (!fileState) {
-        const sessionId = extractShortId(entry.name);
-        fileState = { cursorIndex: 0, sessionId };
-        _state3.files.set(filePath, fileState);
-        console.error(`\u{1F4DD} [Gemini] new session detected: ${entry.name}`);
-      }
-      const r = await flushDeltaForFile3(filePath, fileState);
-      totalI += r.inserted;
-      totalS += r.skipped;
-      totalD += r.dedup;
-    }
-  }
-  return { inserted: totalI, skipped: totalS, dedup: totalD };
-}
 async function flushWithMutex3() {
   if (_flushInProgress3) {
     _flushPending3 = true;
@@ -57318,10 +57653,10 @@ async function flushWithMutex3() {
   try {
     const r = await flushAllFiles3();
     if (r.inserted > 0 || r.skipped > 0 || r.dedup > 0) {
-      console.error(`\u{1F4DD} [Gemini] live flush: inserted=${r.inserted}, dedup=${r.dedup}, skipped=${r.skipped}`);
+      console.error(`\u{1F4DD} [Codex] live flush: inserted=${r.inserted}, dedup=${r.dedup}, skipped=${r.skipped}`);
     }
   } catch (err2) {
-    console.error("\u26A0\uFE0F [Gemini] live flush error:", err2);
+    console.error("\u26A0\uFE0F [Codex] live flush error:", err2);
   } finally {
     _flushInProgress3 = false;
     if (_flushPending3) {
@@ -57339,87 +57674,55 @@ function scheduleFlush3() {
     void flushWithMutex3();
   }, FLUSH_DEBOUNCE_MS3);
 }
-function captureSessionStart3(cwd) {
-  const chatsDirs = deriveChatsDirCandidates(cwd);
-  _state3 = { cwd, chatsDirs, files: /* @__PURE__ */ new Map() };
-  if (chatsDirs.length === 0) {
-    return;
-  }
-  let count = 0;
-  for (const dir of chatsDirs) {
-    let entries;
-    try {
-      entries = fs4.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-      if (!entry.name.startsWith("session-")) continue;
-      const filePath = path5.join(dir, entry.name);
-      let session = null;
-      try {
-        const raw = fs4.readFileSync(filePath, "utf-8");
-        session = JSON.parse(raw);
-      } catch {
-        session = null;
-      }
-      const sessionId = session && typeof session.sessionId === "string" && session.sessionId || extractShortId(entry.name);
-      const cursorIndex = session && Array.isArray(session.messages) ? session.messages.length : 0;
-      _state3.files.set(filePath, { cursorIndex, sessionId });
-      count++;
-    }
-  }
-  console.error(
-    `\u{1F4DD} [Gemini] capture armed: ${count} session(s) across ${chatsDirs.length} chats dir(s)`
-  );
-  armDirWatchers();
-}
-function armDirWatchers() {
-  if (!_state3) return;
-  if (_watchers.length > 0) return;
-  for (const dir of _state3.chatsDirs) {
-    try {
-      const w = fs4.watch(dir, (_evt, filename) => {
-        if (filename && !filename.endsWith(".json")) return;
-        scheduleFlush3();
-      });
-      _watchers.push(w);
-    } catch (err2) {
-      console.error(`\u26A0\uFE0F [Gemini] fs.watch ${dir} failed:`, err2);
-    }
-  }
-  if (_watchers.length > 0) {
-    console.error(`\u{1F4DD} [Gemini] dir watcher(s) armed: ${_watchers.length}`);
+function armDirWatcher2() {
+  if (!_state3 || !_state3.rootExists) return;
+  if (_watcher2) return;
+  try {
+    _watcher2 = fs4.watch(SESSIONS_ROOT, { recursive: true }, (_evt, filename) => {
+      if (!filename) return;
+      const base = path5.basename(filename);
+      if (!base.startsWith("rollout-") || !base.endsWith(".jsonl")) return;
+      scheduleFlush3();
+    });
+    console.error(`\u{1F4DD} [Codex] dir watcher armed (recursive)`);
+  } catch (err2) {
+    console.error("\u26A0\uFE0F [Codex] fs.watch failed \u2014 polling only:", err2);
   }
+  _pollTimer2 = setInterval(() => {
+    void flushWithMutex3();
+  }, POLL_INTERVAL_MS2);
 }
-function disarmDirWatchers() {
+function disarmDirWatcher2() {
   if (_flushDebounceTimer3) {
     clearTimeout(_flushDebounceTimer3);
     _flushDebounceTimer3 = null;
   }
-  for (const w of _watchers) {
+  if (_pollTimer2) {
+    clearInterval(_pollTimer2);
+    _pollTimer2 = null;
+  }
+  if (_watcher2) {
     try {
-      w.close();
+      _watcher2.close();
     } catch {
     }
+    _watcher2 = null;
   }
-  _watchers.length = 0;
 }
 async function captureSessionEnd3() {
-  disarmDirWatchers();
+  disarmDirWatcher2();
   const waitStart = Date.now();
   while (_flushInProgress3 && Date.now() - waitStart < 2e3) {
     await new Promise((r) => setTimeout(r, 50));
   }
-  if (!_state3 || _state3.chatsDirs.length === 0) {
+  if (!_state3 || !_state3.rootExists) {
     return { inserted: 0, skipped: 0, error: "session not armed" };
   }
   _flushInProgress3 = true;
   try {
     const r = await flushAllFiles3();
     if (r.inserted > 0 || r.skipped > 0 || r.dedup > 0) {
-      console.error(`\u{1F4DD} [Gemini] final flush: inserted=${r.inserted}, dedup=${r.dedup}, skipped=${r.skipped}`);
+      console.error(`\u{1F4DD} [Codex] final flush: inserted=${r.inserted}, dedup=${r.dedup}, skipped=${r.skipped}`);
     }
     return { inserted: r.inserted, skipped: r.skipped };
   } finally {
@@ -57503,11 +57806,11 @@ async function shutdown(reason) {
   try {
     await Promise.race([
       Promise.allSettled([
-        captureSessionEnd(),
         captureSessionEnd2(),
-        captureSessionEnd3()
+        captureSessionEnd3(),
+        captureSessionEnd()
       ]),
-      new Promise((resolve2) => setTimeout(resolve2, 3e3))
+      new Promise((resolve) => setTimeout(resolve, 3e3))
     ]);
   } catch (err2) {
     console.error("\u{1F4DD} capture error (non-blocking):", err2);
@@ -57519,7 +57822,7 @@ async function shutdown(reason) {
   try {
     await Promise.race([
       drainColdPath(),
-      new Promise((resolve2) => setTimeout(resolve2, 2e4))
+      new Promise((resolve) => setTimeout(resolve, 2e4))
     ]);
   } catch (err2) {
     console.error("\u{1F535} [ColdPath] drain error (non-blocking):", err2);
@@ -57527,7 +57830,7 @@ async function shutdown(reason) {
   try {
     await Promise.race([
       db.close(),
-      new Promise((resolve2) => setTimeout(resolve2, 3e3))
+      new Promise((resolve) => setTimeout(resolve, 3e3))
     ]);
   } catch (err2) {
     console.error("Error during shutdown:", err2);
@@ -57592,7 +57895,7 @@ Configuration is loaded from (first hit wins):
 Required settings:
   DATABASE_URL=postgres://user:pass@host:5432/db?sslmode=require   (or DB_HOST + DB_USER + DB_PASS + DB_NAME)
   OPENAI_API_KEY=sk-...                                            (embedding text-embedding-3-large)
-  GEMINI_API_KEY=...                                               (Cold Path tagger gemini-2.5-flash)`);
+  XAI_API_KEY=...                                                  (Cold Path tagger/librarian \u2014 grok-4-1-fast-non-reasoning default)`);
 }
 async function runMcpServer() {
   const instructions = await buildInstructions();
@@ -57611,9 +57914,9 @@ async function runMcpServer() {
   registerTools(server);
   installShutdownHandlers();
   startParentWatchdog();
-  captureSessionStart(process.cwd());
   captureSessionStart2(process.cwd());
   captureSessionStart3(process.cwd());
+  captureSessionStart(process.cwd());
   console.error("\u{1F680} Starting Memory MCP Server...");
   if (process.env.SSH_ENABLED === "true" && !process.env.SSH_KEY_PATH) {
     throw new Error("\u274C SSH_KEY_PATH is required when SSH is enabled");