@memtensor/memos-local-openclaw-plugin 1.0.2-beta.5 → 1.0.2-beta.7

package/dist/viewer/html.js.map

@@ -1 +1 @@
-{"version":3,"file":"html.js","sourceRoot":"","sources":["../../src/viewer/html.ts"],"names":[],"mappings":";;AAAA,gCAk4IC;AAl4ID,SAAgB,UAAU,CAAC,aAAsB;IACjD,MAAM,MAAM,GAAG,aAAa,CAAC,CAAC,CAAC,gCAAgC,aAAa,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC;IAC3F,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sDAuvB+C,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAwoHpD,CAAC;AACT,CAAC"}
+{"version":3,"file":"html.js","sourceRoot":"","sources":["../../src/viewer/html.ts"],"names":[],"mappings":";;AAAA,gCA4qJC;AA5qJD,SAAgB,UAAU,CAAC,aAAsB;IACjD,MAAM,MAAM,GAAG,aAAa,CAAC,CAAC,CAAC,gCAAgC,aAAa,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC;IAC3F,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sDAyxB+C,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAg5HpD,CAAC;AACT,CAAC"}

package/dist/viewer/server.d.ts

@@ -65,7 +65,6 @@ export declare class ViewerServer {
     private handleTaskUpdate;
     private handleSkillDelete;
     private handleSkillUpdate;
-    private handleCreate;
     private serveMemoryDetail;
     private handleUpdate;
     private handleDelete;
@@ -79,6 +78,7 @@ export declare class ViewerServer {
     private serveFallbackModel;
     private findPluginPackageJson;
     private handleUpdateCheck;
+    private handleUpdateInstall;
     private testEmbeddingModel;
     private testChatModel;
     private serveLogs;

package/dist/viewer/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/viewer/server.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/viewer/server.ts"],"names":[],"mappings":"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"}

package/dist/viewer/server.js

@@ -1,10 +1,44 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ViewerServer = void 0;
 const node_http_1 = __importDefault(require("node:http"));
+const node_os_1 = __importDefault(require("node:os"));
 const node_crypto_1 = __importDefault(require("node:crypto"));
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = __importDefault(require("node:fs"));
@@ -51,7 +85,7 @@ class ViewerServer {
     migrationSSEClients = [];
     ppRunning = false;
     ppAbort = false;
-    ppState = { running: false, done: false, stopped: false, processed: 0, total: 0, tasksCreated: 0, skillsCreated: 0, errors: 0 };
+    ppState = { running: false, done: false, stopped: false, processed: 0, total: 0, tasksCreated: 0, skillsCreated: 0, errors: 0, skippedSessions: 0, totalSessions: 0 };
     ppSSEClients = [];
     constructor(opts) {
         this.store = opts.store;
@@ -222,8 +256,6 @@ class ViewerServer {
                 this.handleSkillUpdate(req, res, p);
             else if (p.startsWith("/api/skill/") && req.method === "GET")
                 this.serveSkillDetail(res, p);
-            else if (p === "/api/memory" && req.method === "POST")
-                this.handleCreate(req, res);
             else if (p.startsWith("/api/memory/") && req.method === "GET")
                 this.serveMemoryDetail(res, p);
             else if (p.startsWith("/api/memory/") && req.method === "PUT")
@@ -250,6 +282,8 @@ class ViewerServer {
                 this.serveFallbackModel(res);
             else if (p === "/api/update-check" && req.method === "GET")
                 this.handleUpdateCheck(res);
+            else if (p === "/api/update-install" && req.method === "POST")
+                this.handleUpdateInstall(req, res);
             else if (p === "/api/auth/logout" && req.method === "POST")
                 this.handleLogout(req, res);
             else if (p === "/api/cleanup-polluted" && req.method === "POST")
@@ -390,7 +424,6 @@ class ViewerServer {
         const offset = (page - 1) * limit;
         const session = url.searchParams.get("session") ?? undefined;
         const role = url.searchParams.get("role") ?? undefined;
-        const kind = url.searchParams.get("kind") ?? undefined;
         const dateFrom = url.searchParams.get("dateFrom") ?? undefined;
         const dateTo = url.searchParams.get("dateTo") ?? undefined;
         const owner = url.searchParams.get("owner") ?? undefined;
@@ -406,10 +439,6 @@ class ViewerServer {
             conditions.push("role = ?");
             params.push(role);
         }
-        if (kind) {
-            conditions.push("kind = ?");
-            params.push(kind);
-        }
         if (owner) {
             conditions.push("owner = ?");
             params.push(owner);
@@ -425,9 +454,14 @@ class ViewerServer {
         const where = conditions.length > 0 ? " WHERE " + conditions.join(" AND ") : "";
         const totalRow = db.prepare("SELECT COUNT(*) as count FROM chunks" + where).get(...params);
         const rawMemories = db.prepare("SELECT * FROM chunks" + where + ` ORDER BY created_at ${sortBy} LIMIT ? OFFSET ?`).all(...params, limit, offset);
+        const findMergeSources = db.prepare("SELECT id, summary, role FROM chunks WHERE dedup_target = ? AND (dedup_status = 'merged' OR dedup_status = 'duplicate')");
         const memories = rawMemories.map((m) => {
             if (m.role === "user" && m.content) {
-                return { ...m, content: (0, capture_1.stripInboundMetadata)(m.content) };
+                m = { ...m, content: (0, capture_1.stripInboundMetadata)(m.content) };
+            }
+            if (m.merge_count > 0) {
+                const sources = findMergeSources.all(m.id);
+                m.merge_sources = sources;
             }
             return m;
         });
@@ -460,7 +494,7 @@ class ViewerServer {
                 id: t.id,
                 sessionKey: t.sessionKey,
                 title: t.title,
-                summary: t.summary ? (t.summary.length > 300 ? t.summary.slice(0, 297) + "..." : t.summary) : "",
+                summary: t.summary ?? "",
                 status: t.status,
                 startedAt: t.startedAt,
                 endedAt: t.endedAt,
@@ -480,9 +514,7 @@ class ViewerServer {
         }
         const chunks = this.store.getChunksByTask(taskId);
         const chunkItems = chunks.map((c) => {
-            let text = c.role === "user" ? (0, capture_1.stripInboundMetadata)(c.content) : c.content;
-            if (text.length > 500)
-                text = text.slice(0, 497) + "...";
+            const text = c.role === "user" ? (0, capture_1.stripInboundMetadata)(c.content) : c.content;
             return { id: c.id, role: c.role, content: text, summary: c.summary, createdAt: c.createdAt };
         });
         const relatedSkills = this.store.getSkillsByTask(taskId);
@@ -514,7 +546,7 @@ class ViewerServer {
         const emptyStats = {
             totalMemories: 0, totalSessions: 0, totalEmbeddings: 0, totalSkills: 0,
             embeddingProvider: this.embedder?.provider ?? "none",
-            roleBreakdown: {}, kindBreakdown: {}, dedupBreakdown: {},
+            dedupBreakdown: {},
             timeRange: { earliest: null, latest: null },
             sessions: [],
         };
@@ -526,7 +558,6 @@ class ViewerServer {
             const db = this.store.db;
             const total = db.prepare("SELECT COUNT(*) as count FROM chunks").get();
             const sessions = db.prepare("SELECT COUNT(DISTINCT session_key) as count FROM chunks").get();
-            const roles = db.prepare("SELECT role, COUNT(*) as count FROM chunks GROUP BY role").all();
             const timeRange = db.prepare("SELECT MIN(created_at) as earliest, MAX(created_at) as latest FROM chunks WHERE dedup_status = 'active'").get();
             const MIN_VALID_TS = 1704067200000; // 2024-01-01
             if (timeRange.earliest != null && timeRange.earliest < MIN_VALID_TS) {
@@ -541,7 +572,6 @@ class ViewerServer {
                 embCount = db.prepare("SELECT COUNT(*) as count FROM embeddings").get().count;
             }
             catch { /* table may not exist */ }
-            const kinds = db.prepare("SELECT kind, COUNT(*) as count FROM chunks GROUP BY kind").all();
             const sessionList = db.prepare("SELECT session_key, COUNT(*) as count, MIN(created_at) as earliest, MAX(created_at) as latest FROM chunks GROUP BY session_key ORDER BY latest DESC").all();
             let skillCount = 0;
             try {
@@ -564,8 +594,6 @@ class ViewerServer {
                 totalMemories: total.count, totalSessions: sessions.count, totalEmbeddings: embCount,
                 totalSkills: skillCount,
                 embeddingProvider: this.embedder.provider,
-                roleBreakdown: Object.fromEntries(roles.map((r) => [r.role, r.count])),
-                kindBreakdown: Object.fromEntries(kinds.map((k) => [k.kind, k.count])),
                 dedupBreakdown,
                 timeRange: { earliest: timeRange.earliest, latest: timeRange.latest },
                 sessions: sessionList,
@@ -584,7 +612,6 @@ class ViewerServer {
             return;
         }
         const role = url.searchParams.get("role") ?? undefined;
-        const kind = url.searchParams.get("kind") ?? undefined;
         const session = url.searchParams.get("session") ?? undefined;
         const owner = url.searchParams.get("owner") ?? undefined;
         const dateFrom = url.searchParams.get("dateFrom") ?? undefined;
@@ -592,8 +619,6 @@ class ViewerServer {
         const passesFilter = (r) => {
             if (role && r.role !== role)
                 return false;
-            if (kind && r.kind !== kind)
-                return false;
             if (session && r.session_key !== session)
                 return false;
             if (owner && r.owner !== owner)
@@ -961,35 +986,6 @@ class ViewerServer {
         });
     }
     // ─── CRUD ───
-    handleCreate(req, res) {
-        this.readBody(req, (body) => {
-            try {
-                const data = JSON.parse(body);
-                if (!data.content || typeof data.content !== "string" || !data.content.trim()) {
-                    res.writeHead(400, { "Content-Type": "application/json" });
-                    res.end(JSON.stringify({ error: "content is required and must be a non-empty string" }));
-                    return;
-                }
-                const { v4: uuidv4 } = require("uuid");
-                const id = uuidv4();
-                const now = Date.now();
-                this.store.insertChunk({
-                    id, sessionKey: data.session_key || "manual", turnId: `manual-${now}`, seq: 0,
-                    role: data.role || "user", content: data.content, kind: data.kind || "paragraph",
-                    summary: data.summary || data.content.slice(0, 100),
-                    taskId: null, skillId: null, owner: data.owner || "agent:main",
-                    dedupStatus: "active", dedupTarget: null, dedupReason: null,
-                    mergeCount: 0, lastHitAt: null, mergeHistory: "[]",
-                    createdAt: now, updatedAt: now, embedding: null,
-                });
-                this.jsonResponse(res, { ok: true, id, message: "Memory created" });
-            }
-            catch (err) {
-                res.writeHead(400, { "Content-Type": "application/json" });
-                res.end(JSON.stringify({ error: String(err) }));
-            }
-        });
-    }
     serveMemoryDetail(res, urlPath) {
         const chunkId = urlPath.replace("/api/memory/", "");
         const chunk = this.store.getChunk(chunkId);
@@ -1013,7 +1009,7 @@ class ViewerServer {
                     res.end(JSON.stringify({ error: "content must be a non-empty string" }));
                     return;
                 }
-                const ok = this.store.updateChunk(chunkId, { summary: data.summary, content: data.content, role: data.role, kind: data.kind, owner: data.owner });
+                const ok = this.store.updateChunk(chunkId, { summary: data.summary, content: data.content, role: data.role, owner: data.owner });
                 if (ok)
                     this.jsonResponse(res, { ok: true, message: "Memory updated" });
                 else {
@@ -1239,20 +1235,20 @@ class ViewerServer {
                 this.jsonResponse(res, { updateAvailable: false, current });
                 return;
             }
-            const npmResp = await fetch(`https://registry.npmjs.org/${name}/latest`, {
-                signal: AbortSignal.timeout(6_000),
-            });
-            if (!npmResp.ok) {
-                this.jsonResponse(res, { updateAvailable: false, current });
+            const { computeUpdateCheck } = await Promise.resolve().then(() => __importStar(require("../update-check")));
+            const result = await computeUpdateCheck(name, current, fetch, 6_000);
+            if (!result) {
+                this.jsonResponse(res, { updateAvailable: false, current, packageName: name });
                 return;
             }
-            const data = await npmResp.json();
-            const latest = data.version ?? current;
             this.jsonResponse(res, {
-                updateAvailable: latest !== current,
-                current,
-                latest,
-                packageName: name,
+                updateAvailable: result.updateAvailable,
+                current: result.current,
+                latest: result.latest,
+                packageName: result.packageName,
+                channel: result.channel,
+                installCommand: result.installCommand,
+                stableChannel: result.stableChannel,
             });
         }
         catch (e) {
@@ -1260,6 +1256,146 @@ class ViewerServer {
             this.jsonResponse(res, { updateAvailable: false, error: String(e) });
         }
     }
+    handleUpdateInstall(req, res) {
+        let body = "";
+        req.on("data", (chunk) => { body += chunk.toString(); });
+        req.on("end", () => {
+            try {
+                const { packageSpec: rawSpec } = JSON.parse(body);
+                if (!rawSpec || typeof rawSpec !== "string") {
+                    res.writeHead(400, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ ok: false, error: "Missing packageSpec" }));
+                    return;
+                }
+                const packageSpec = rawSpec.trim().replace(/^(?:npx\s+)?openclaw\s+plugins\s+install\s+/i, "");
+                const allowed = /^@[\w-]+\/[\w.-]+(@[\w.-]+)?$/;
+                this.log.info(`update-install: received packageSpec="${packageSpec}" (len=${packageSpec.length})`);
+                if (!allowed.test(packageSpec)) {
+                    this.log.warn(`update-install: rejected packageSpec="${packageSpec}" — does not match ${allowed}`);
+                    res.writeHead(400, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ ok: false, error: `Invalid package spec: "${packageSpec}"` }));
+                    return;
+                }
+                const pkgPath = this.findPluginPackageJson();
+                const pluginName = pkgPath
+                    ? (() => { try {
+                        return JSON.parse(node_fs_1.default.readFileSync(pkgPath, "utf-8")).name;
+                    }
+                    catch {
+                        return null;
+                    } })()
+                    : null;
+                const shortName = pluginName?.replace(/^@[\w-]+\//, "") ?? "memos-local-openclaw-plugin";
+                const extDir = node_path_1.default.join(node_os_1.default.homedir(), ".openclaw", "extensions", shortName);
+                const tmpDir = node_path_1.default.join(node_os_1.default.tmpdir(), `openclaw-update-${Date.now()}`);
+                // Download via npm pack, extract, and replace extension dir.
+                // Does NOT touch openclaw.json → no config watcher SIGUSR1.
+                this.log.info(`update-install: downloading ${packageSpec} via npm pack...`);
+                node_fs_1.default.mkdirSync(tmpDir, { recursive: true });
+                (0, node_child_process_1.exec)(`npm pack ${packageSpec} --pack-destination ${tmpDir}`, { timeout: 60_000 }, (packErr, packOut) => {
+                    if (packErr) {
+                        this.log.warn(`update-install: npm pack failed: ${packErr.message}`);
+                        this.jsonResponse(res, { ok: false, error: `Download failed: ${packErr.message}` });
+                        try {
+                            node_fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+                        }
+                        catch { }
+                        return;
+                    }
+                    const tgzFile = packOut.trim().split("\n").pop();
+                    const tgzPath = node_path_1.default.join(tmpDir, tgzFile);
+                    this.log.info(`update-install: downloaded ${tgzFile}, extracting...`);
+                    const extractDir = node_path_1.default.join(tmpDir, "extract");
+                    node_fs_1.default.mkdirSync(extractDir, { recursive: true });
+                    (0, node_child_process_1.exec)(`tar -xzf ${tgzPath} -C ${extractDir}`, { timeout: 30_000 }, (tarErr) => {
+                        if (tarErr) {
+                            this.log.warn(`update-install: tar extract failed: ${tarErr.message}`);
+                            this.jsonResponse(res, { ok: false, error: `Extract failed: ${tarErr.message}` });
+                            try {
+                                node_fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+                            }
+                            catch { }
+                            return;
+                        }
+                        // npm pack extracts to a "package" subdirectory
+                        const srcDir = node_path_1.default.join(extractDir, "package");
+                        if (!node_fs_1.default.existsSync(srcDir)) {
+                            this.jsonResponse(res, { ok: false, error: "Extracted package has no 'package' dir" });
+                            try {
+                                node_fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+                            }
+                            catch { }
+                            return;
+                        }
+                        // Replace extension directory
+                        this.log.info(`update-install: replacing ${extDir}...`);
+                        try {
+                            node_fs_1.default.rmSync(extDir, { recursive: true, force: true });
+                        }
+                        catch { }
+                        node_fs_1.default.mkdirSync(node_path_1.default.dirname(extDir), { recursive: true });
+                        node_fs_1.default.renameSync(srcDir, extDir);
+                        // Install dependencies
+                        this.log.info(`update-install: installing dependencies...`);
+                        (0, node_child_process_1.exec)(`cd ${extDir} && npm install --omit=dev --ignore-scripts`, { timeout: 120_000 }, (npmErr, npmOut, npmStderr) => {
+                            if (npmErr) {
+                                try {
+                                    node_fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+                                }
+                                catch { }
+                                this.log.warn(`update-install: npm install failed: ${npmErr.message}`);
+                                this.jsonResponse(res, { ok: false, error: `Dependency install failed: ${npmStderr || npmErr.message}` });
+                                return;
+                            }
+                            // Rebuild native modules (do not swallow errors)
+                            (0, node_child_process_1.exec)(`cd ${extDir} && npm rebuild better-sqlite3`, { timeout: 60_000 }, (rebuildErr, rebuildOut, rebuildStderr) => {
+                                if (rebuildErr) {
+                                    this.log.warn(`update-install: better-sqlite3 rebuild failed: ${rebuildErr.message}`);
+                                    const stderr = String(rebuildStderr || "").trim();
+                                    if (stderr)
+                                        this.log.warn(`update-install: rebuild stderr: ${stderr.slice(0, 500)}`);
+                                    // Continue so postinstall.cjs can run (it will try rebuild again and show user guidance)
+                                }
+                                // Run postinstall.cjs: legacy cleanup, skill install, version marker, and optional sqlite re-check
+                                this.log.info(`update-install: running postinstall...`);
+                                (0, node_child_process_1.exec)(`cd ${extDir} && node scripts/postinstall.cjs`, { timeout: 180_000 }, (postErr, postOut, postStderr) => {
+                                    try {
+                                        node_fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+                                    }
+                                    catch { }
+                                    if (postErr) {
+                                        this.log.warn(`update-install: postinstall failed: ${postErr.message}`);
+                                        const postStderrStr = String(postStderr || "").trim();
+                                        if (postStderrStr)
+                                            this.log.warn(`update-install: postinstall stderr: ${postStderrStr.slice(0, 500)}`);
+                                        // Still report success; plugin is updated, user can run postinstall manually if needed
+                                    }
+                                    // Read new version
+                                    let newVersion = "unknown";
+                                    try {
+                                        const newPkg = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(extDir, "package.json"), "utf-8"));
+                                        newVersion = newPkg.version ?? newVersion;
+                                    }
+                                    catch { }
+                                    this.log.info(`update-install: success! Updated to ${newVersion}`);
+                                    this.jsonResponse(res, { ok: true, version: newVersion });
+                                    // Trigger Gateway restart after response is sent
+                                    setTimeout(() => {
+                                        this.log.info(`update-install: triggering gateway restart...`);
+                                        process.kill(process.pid, "SIGUSR1");
+                                    }, 500);
+                                });
+                            });
+                        });
+                    });
+                });
+            }
+            catch (e) {
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ ok: false, error: String(e) }));
+            }
+        });
+    }
     async testEmbeddingModel(provider, model, endpoint, apiKey) {
         if (provider === "local") {
             return 384;
@@ -1492,10 +1628,16 @@ class ViewerServer {
                 catch { /* ignore */ }
             }
             let importedSessions = [];
+            let importedChunkCount = 0;
             try {
                 if (this.store) {
                     importedSessions = this.store.getDistinctSessionKeys()
                         .filter((sk) => sk.startsWith("openclaw-import-") || sk.startsWith("openclaw-session-"));
+                    if (importedSessions.length > 0) {
+                        const placeholders = importedSessions.map(() => "?").join(",");
+                        const row = this.store.db.prepare(`SELECT COUNT(*) as cnt FROM chunks WHERE session_key IN (${placeholders})`).get(...importedSessions);
+                        importedChunkCount = row?.cnt ?? 0;
+                    }
                 }
             }
             catch (storeErr) {
@@ -1510,6 +1652,7 @@ class ViewerServer {
                 hasSummarizer,
                 hasImportedData: importedSessions.length > 0,
                 importedSessionCount: importedSessions.length,
+                importedChunkCount,
             });
         }
         catch (e) {
@@ -1646,14 +1789,17 @@ class ViewerServer {
                 else {
                     this.broadcastSSE("done", { ok: true });
                 }
-                for (const c of this.migrationSSEClients) {
-                    try {
-                        c.end();
-                    }
-                    catch { /* ignore */ }
-                }
-                this.migrationSSEClients = [];
                 this.migrationAbort = false;
+                const clientsToClose = [...this.migrationSSEClients];
+                this.migrationSSEClients = [];
+                setTimeout(() => {
+                    for (const c of clientsToClose) {
+                        try {
+                            c.end();
+                        }
+                        catch { /* ignore */ }
+                    }
+                }, 500);
             });
         });
     }
@@ -2085,7 +2231,7 @@ class ViewerServer {
             this.ppSSEClients.push(res);
             res.on("close", () => { this.ppSSEClients = this.ppSSEClients.filter(c => c !== res); });
             this.ppAbort = false;
-            this.ppState = { running: true, done: false, stopped: false, processed: 0, total: 0, tasksCreated: 0, skillsCreated: 0, errors: 0 };
+            this.ppState = { running: true, done: false, stopped: false, processed: 0, total: 0, tasksCreated: 0, skillsCreated: 0, errors: 0, skippedSessions: 0, totalSessions: 0 };
             const send = (event, data) => {
                 this.broadcastPPSSE(event, data);
             };
@@ -2101,14 +2247,17 @@ class ViewerServer {
                 else {
                     this.broadcastPPSSE("done", { ...this.ppState });
                 }
-                for (const c of this.ppSSEClients) {
-                    try {
-                        c.end();
-                    }
-                    catch { /* */ }
-                }
-                this.ppSSEClients = [];
                 this.ppAbort = false;
+                const ppClientsToClose = [...this.ppSSEClients];
+                this.ppSSEClients = [];
+                setTimeout(() => {
+                    for (const c of ppClientsToClose) {
+                        try {
+                            c.end();
+                        }
+                        catch { /* */ }
+                    }
+                }, 500);
             });
         });
     }
@@ -2138,7 +2287,14 @@ class ViewerServer {
         this.jsonResponse(res, { ok: true });
     }
     handlePostprocessStatus(res) {
-        this.jsonResponse(res, this.ppState);
+        let existingTasks = 0;
+        let existingSkills = 0;
+        try {
+            existingTasks = this.store.db.prepare("SELECT COUNT(*) as c FROM tasks").get()?.c ?? 0;
+            existingSkills = this.store.countSkills("active");
+        }
+        catch { /* */ }
+        this.jsonResponse(res, { ...this.ppState, existingTasks, existingSkills });
     }
     broadcastPPSSE(event, data) {
         const payload = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
@@ -2178,12 +2334,18 @@ class ViewerServer {
             agentGroups.set(item.owner, group);
         }
         this.ppState.total = pendingItems.length;
+        this.ppState.skippedSessions = skippedCount;
+        this.ppState.totalSessions = importSessions.length;
+        const existingTaskCount = this.store.db.prepare("SELECT COUNT(*) as c FROM tasks WHERE session_key IN (" + importSessions.map(() => "?").join(",") + ")").get(...importSessions)?.c ?? 0;
+        const existingSkillCount = this.store.countSkills("active");
         send("info", {
             totalSessions: importSessions.length,
             alreadyProcessed: skippedCount,
             pending: pendingItems.length,
             agents: Array.from(agentGroups.keys()),
             concurrency,
+            existingTasks: existingTaskCount,
+            existingSkills: existingSkillCount,
         });
         send("progress", { processed: 0, total: pendingItems.length });
         let globalIdx = 0;