@memtensor/memos-local-openclaw-plugin 0.3.19 → 1.0.0

package/dist/viewer/server.js

@@ -168,6 +168,12 @@ class ViewerServer {
                 this.serveSearch(req, res, url);
             else if (p === "/api/tasks" && req.method === "GET")
                 this.serveTasks(res, url);
+            else if (p.match(/^\/api\/task\/[^/]+\/retry-skill$/) && req.method === "POST")
+                this.handleTaskRetrySkill(req, res, p);
+            else if (p.startsWith("/api/task/") && req.method === "DELETE")
+                this.handleTaskDelete(res, p);
+            else if (p.startsWith("/api/task/") && req.method === "PUT")
+                this.handleTaskUpdate(req, res, p);
             else if (p.startsWith("/api/task/") && req.method === "GET")
                 this.serveTaskDetail(res, p);
             else if (p === "/api/skills" && req.method === "GET")
@@ -178,6 +184,10 @@ class ViewerServer {
                 this.serveSkillFiles(res, p);
             else if (p.match(/^\/api\/skill\/[^/]+\/visibility$/) && req.method === "PUT")
                 this.handleSkillVisibility(req, res, p);
+            else if (p.startsWith("/api/skill/") && req.method === "DELETE")
+                this.handleSkillDelete(res, p);
+            else if (p.startsWith("/api/skill/") && req.method === "PUT")
+                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")
@@ -401,16 +411,21 @@ class ViewerServer {
         const limit = Math.min(100, Math.max(1, Number(url.searchParams.get("limit")) || 50));
         const offset = Math.max(0, Number(url.searchParams.get("offset")) || 0);
         const { tasks, total } = this.store.listTasks({ status, limit, offset });
-        const items = tasks.map((t) => ({
-            id: t.id,
-            sessionKey: t.sessionKey,
-            title: t.title,
-            summary: t.summary ? (t.summary.length > 300 ? t.summary.slice(0, 297) + "..." : t.summary) : "",
-            status: t.status,
-            startedAt: t.startedAt,
-            endedAt: t.endedAt,
-            chunkCount: this.store.countChunksByTask(t.id),
-        }));
+        const db = this.store.db;
+        const items = tasks.map((t) => {
+            const meta = db.prepare("SELECT skill_status FROM tasks WHERE id = ?").get(t.id);
+            return {
+                id: t.id,
+                sessionKey: t.sessionKey,
+                title: t.title,
+                summary: t.summary ? (t.summary.length > 300 ? t.summary.slice(0, 297) + "..." : t.summary) : "",
+                status: t.status,
+                startedAt: t.startedAt,
+                endedAt: t.endedAt,
+                chunkCount: this.store.countChunksByTask(t.id),
+                skillStatus: meta?.skill_status ?? null,
+            };
+        });
         this.jsonResponse(res, { tasks: items, total, limit, offset });
     }
     serveTaskDetail(res, urlPath) {
@@ -541,15 +556,17 @@ class ViewerServer {
         catch {
             ftsResults = db.prepare("SELECT * FROM chunks WHERE content LIKE ? OR summary LIKE ? ORDER BY created_at DESC LIMIT 100").all(`%${q}%`, `%${q}%`).filter(passesFilter);
         }
+        const SEMANTIC_THRESHOLD = 0.64;
         let vectorResults = [];
+        let scoreMap = new Map();
         try {
             const queryVec = await this.embedder.embedQuery(q);
             const hits = (0, vector_1.vectorSearch)(this.store, queryVec, 40);
-            const hitIds = new Set(hits.filter(h => h.score > 0.3).map(h => h.chunkId));
+            scoreMap = new Map(hits.map(h => [h.chunkId, h.score]));
+            const hitIds = new Set(hits.filter(h => h.score >= SEMANTIC_THRESHOLD).map(h => h.chunkId));
             if (hitIds.size > 0) {
                 const placeholders = [...hitIds].map(() => "?").join(",");
                 const rows = db.prepare(`SELECT * FROM chunks WHERE id IN (${placeholders})`).all(...hitIds).filter(passesFilter);
-                const scoreMap = new Map(hits.map(h => [h.chunkId, h.score]));
                 rows.forEach((r) => { r._vscore = scoreMap.get(r.id) ?? 0; });
                 rows.sort((a, b) => (b._vscore ?? 0) - (a._vscore ?? 0));
                 vectorResults = rows;
@@ -567,18 +584,24 @@ class ViewerServer {
             }
         }
         for (const r of ftsResults) {
-            if (!seenIds.has(r.id)) {
-                seenIds.add(r.id);
-                merged.push(r);
-            }
+            if (seenIds.has(r.id))
+                continue;
+            const vscore = scoreMap.get(r.id);
+            if (vscore !== undefined && vscore < SEMANTIC_THRESHOLD)
+                continue;
+            seenIds.add(r.id);
+            merged.push(r);
         }
+        const fallback = merged.length === 0 && ftsResults.length > 0;
+        const results = fallback ? ftsResults.slice(0, 20) : merged;
         this.store.recordViewerEvent("search");
         this.jsonResponse(res, {
-            results: merged,
+            results,
             query: q,
             vectorCount: vectorResults.length,
             ftsCount: ftsResults.length,
-            total: merged.length,
+            total: results.length,
+            fallbackFts: fallback,
         });
     }
     // ─── Skills API ───
@@ -737,18 +760,138 @@ class ViewerServer {
             }
         });
     }
+    // ─── Task/Skill management ───
+    handleTaskRetrySkill(_req, res, urlPath) {
+        const taskId = urlPath.replace("/api/task/", "").replace("/retry-skill", "");
+        const task = this.store.getTask(taskId);
+        if (!task) {
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Task not found" }));
+            return;
+        }
+        if (task.status !== "completed") {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Only completed tasks can retry skill generation" }));
+            return;
+        }
+        if (!this.ctx) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Plugin context not available" }));
+            return;
+        }
+        // Clean up stale task_skills references (e.g., skill was manually deleted)
+        const db = this.store.db;
+        db.prepare("DELETE FROM task_skills WHERE task_id = ? AND skill_id NOT IN (SELECT id FROM skills)").run(taskId);
+        this.store.setTaskSkillMeta(taskId, { skillStatus: "queued", skillReason: "手动重试中..." });
+        this.jsonResponse(res, { ok: true, taskId, status: "queued" });
+        const ctx = this.ctx;
+        const recallEngine = new engine_1.RecallEngine(this.store, this.embedder, ctx);
+        const evolver = new evolver_1.SkillEvolver(this.store, recallEngine, ctx, this.embedder);
+        evolver.onTaskCompleted(task).then(() => {
+            this.log.info(`Retry skill generation completed for task ${taskId}`);
+        }).catch((err) => {
+            this.log.error(`Retry skill generation failed for task ${taskId}: ${err}`);
+            this.store.setTaskSkillMeta(taskId, { skillStatus: "skipped", skillReason: `error: ${err}` });
+        });
+    }
+    handleTaskDelete(res, urlPath) {
+        const taskId = urlPath.replace("/api/task/", "");
+        const deleted = this.store.deleteTask(taskId);
+        if (!deleted) {
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Task not found" }));
+            return;
+        }
+        this.jsonResponse(res, { ok: true, taskId });
+    }
+    handleTaskUpdate(req, res, urlPath) {
+        const taskId = urlPath.replace("/api/task/", "");
+        this.readBody(req, (body) => {
+            try {
+                const data = JSON.parse(body);
+                const task = this.store.getTask(taskId);
+                if (!task) {
+                    res.writeHead(404, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "Task not found" }));
+                    return;
+                }
+                this.store.updateTask(taskId, {
+                    title: data.title ?? task.title,
+                    summary: data.summary ?? task.summary,
+                    status: data.status ?? task.status,
+                    endedAt: task.endedAt ?? undefined,
+                });
+                this.jsonResponse(res, { ok: true, taskId });
+            }
+            catch (err) {
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: String(err) }));
+            }
+        });
+    }
+    handleSkillDelete(res, urlPath) {
+        const skillId = urlPath.replace("/api/skill/", "");
+        const skill = this.store.getSkill(skillId);
+        if (!skill) {
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Skill not found" }));
+            return;
+        }
+        // Remove skill directory from disk
+        try {
+            if (skill.dirPath && node_fs_1.default.existsSync(skill.dirPath)) {
+                node_fs_1.default.rmSync(skill.dirPath, { recursive: true, force: true });
+            }
+        }
+        catch (err) {
+            this.log.warn(`Failed to remove skill directory ${skill.dirPath}: ${err}`);
+        }
+        this.store.deleteSkill(skillId);
+        this.jsonResponse(res, { ok: true, skillId });
+    }
+    handleSkillUpdate(req, res, urlPath) {
+        const skillId = urlPath.replace("/api/skill/", "");
+        this.readBody(req, (body) => {
+            try {
+                const data = JSON.parse(body);
+                const skill = this.store.getSkill(skillId);
+                if (!skill) {
+                    res.writeHead(404, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "Skill not found" }));
+                    return;
+                }
+                this.store.updateSkill(skillId, {
+                    description: data.description ?? skill.description,
+                    version: skill.version,
+                    status: data.status ?? skill.status,
+                    installed: skill.installed,
+                    qualityScore: skill.qualityScore,
+                });
+                this.jsonResponse(res, { ok: true, skillId });
+            }
+            catch (err) {
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: String(err) }));
+            }
+        });
+    }
     // ─── 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) || "",
+                    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: "[]",
@@ -780,6 +923,11 @@ class ViewerServer {
         this.readBody(req, (body) => {
             try {
                 const data = JSON.parse(body);
+                if (data.content !== undefined && (typeof data.content !== "string" || !data.content.trim())) {
+                    res.writeHead(400, { "Content-Type": "application/json" });
+                    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 });
                 if (ok)
                     this.jsonResponse(res, { ok: true, message: "Memory updated" });
@@ -1108,6 +1256,7 @@ class ViewerServer {
                 opts = JSON.parse(body);
             }
             catch { /* defaults */ }
+            const concurrency = Math.max(1, Math.min(opts.concurrency ?? 1, 8));
             res.writeHead(200, {
                 "Content-Type": "text/event-stream",
                 "Cache-Control": "no-cache",
@@ -1144,7 +1293,7 @@ class ViewerServer {
                 this.broadcastSSE(event, data);
             };
             this.migrationRunning = true;
-            this.runMigration(send, opts.sources).finally(() => {
+            this.runMigration(send, opts.sources, concurrency).finally(() => {
                 this.migrationRunning = false;
                 this.migrationState.done = true;
                 if (this.migrationAbort) {
@@ -1165,7 +1314,7 @@ class ViewerServer {
             });
         });
     }
-    async runMigration(send, sources) {
+    async runMigration(send, sources, concurrency = 1) {
         const ocHome = this.getOpenClawHome();
         const importSqlite = !sources || sources.includes("sqlite");
         const importSessions = !sources || sources.includes("sessions");
@@ -1175,15 +1324,17 @@ class ViewerServer {
         let totalErrors = 0;
         const cfgPath = this.getOpenClawConfigPath();
         let summarizerCfg;
+        let strongCfg;
         try {
             const raw = JSON.parse(node_fs_1.default.readFileSync(cfgPath, "utf-8"));
             const pluginCfg = raw?.plugins?.entries?.["memos-local-openclaw-plugin"]?.config ??
                 raw?.plugins?.entries?.["memos-lite"]?.config ??
                 raw?.plugins?.entries?.["memos-lite-openclaw-plugin"]?.config ?? {};
             summarizerCfg = pluginCfg.summarizer;
+            strongCfg = pluginCfg.skillEvolution?.summarizer;
         }
         catch { /* no config */ }
-        const summarizer = new providers_1.Summarizer(summarizerCfg, this.log);
+        const summarizer = new providers_1.Summarizer(summarizerCfg, this.log, strongCfg);
         // Phase 1: Import SQLite memory chunks
         if (importSqlite) {
             const memoryDir = node_path_1.default.join(ocHome, "memory");
@@ -1218,6 +1369,21 @@ class ViewerServer {
                                 });
                                 continue;
                             }
+                            const importOwner = `agent:${agentId}`;
+                            // Exact hash dedup within same agent
+                            const existingByHash = this.store.findActiveChunkByHash(row.text, importOwner);
+                            if (existingByHash) {
+                                totalSkipped++;
+                                send("item", {
+                                    index: i + 1,
+                                    total: rows.length,
+                                    status: "skipped",
+                                    preview: row.text.slice(0, 120),
+                                    source: file,
+                                    reason: "exact duplicate within agent",
+                                });
+                                continue;
+                            }
                             try {
                                 const summary = await summarizer.summarize(row.text);
                                 let embedding = null;
@@ -1231,7 +1397,9 @@ class ViewerServer {
                                 let dedupTarget = null;
                                 let dedupReason = null;
                                 if (embedding) {
-                                    const topSimilar = (0, dedup_1.findTopSimilar)(this.store, embedding, 0.85, 3, this.log);
+                                    const importThreshold = this.ctx?.config?.dedup?.similarityThreshold ?? 0.60;
+                                    const dedupOwnerFilter = [importOwner];
+                                    const topSimilar = (0, dedup_1.findTopSimilar)(this.store, embedding, importThreshold, 5, this.log, dedupOwnerFilter);
                                     if (topSimilar.length > 0) {
                                         const candidates = topSimilar.map((s, idx) => {
                                             const chunk = this.store.getChunk(s.chunkId);
@@ -1322,17 +1490,32 @@ class ViewerServer {
                 }
             }
         }
-        // Phase 2: Import session JSONL files
+        // Phase 2: Import session JSONL files from ALL agents (supports parallel by agent)
         if (importSessions) {
-            const sessionsDir = node_path_1.default.join(ocHome, "agents", "main", "sessions");
-            if (node_fs_1.default.existsSync(sessionsDir)) {
-                const jsonlFiles = node_fs_1.default.readdirSync(sessionsDir).filter(f => f.includes(".jsonl")).sort();
-                send("phase", { phase: "sessions", files: jsonlFiles.length });
-                let globalMsgIdx = 0;
-                let totalMsgs = 0;
-                for (const f of jsonlFiles) {
+            const agentsDir = node_path_1.default.join(ocHome, "agents");
+            const agentGroups = new Map();
+            if (node_fs_1.default.existsSync(agentsDir)) {
+                for (const entry of node_fs_1.default.readdirSync(agentsDir, { withFileTypes: true })) {
+                    if (entry.isDirectory()) {
+                        const sessDir = node_path_1.default.join(agentsDir, entry.name, "sessions");
+                        if (node_fs_1.default.existsSync(sessDir)) {
+                            const jsonlFiles = node_fs_1.default.readdirSync(sessDir).filter(f => f.includes(".jsonl")).sort();
+                            if (jsonlFiles.length > 0) {
+                                agentGroups.set(entry.name, jsonlFiles.map(f => ({ file: f, filePath: node_path_1.default.join(sessDir, f) })));
+                            }
+                        }
+                    }
+                }
+            }
+            const agentIds = Array.from(agentGroups.keys());
+            const allFileCount = Array.from(agentGroups.values()).reduce((s, g) => s + g.length, 0);
+            send("phase", { phase: "sessions", files: allFileCount, agents: agentIds, concurrency });
+            // Count total messages across all agents
+            let totalMsgs = 0;
+            for (const files of agentGroups.values()) {
+                for (const { filePath } of files) {
                     try {
-                        const raw = node_fs_1.default.readFileSync(node_path_1.default.join(sessionsDir, f), "utf-8");
+                        const raw = node_fs_1.default.readFileSync(filePath, "utf-8");
                         for (const line of raw.split("\n")) {
                             if (!line.trim())
                                 continue;
@@ -1361,12 +1544,17 @@ class ViewerServer {
                     }
                     catch { /* skip */ }
                 }
-                for (const file of jsonlFiles) {
+            }
+            // Thread-safe counters for parallel execution
+            let globalMsgIdx = 0;
+            const incIdx = () => ++globalMsgIdx;
+            // Import one agent's sessions sequentially
+            const importAgent = async (agentId, files) => {
+                const agentOwner = `agent:${agentId}`;
+                for (const { file, filePath } of files) {
                     if (this.migrationAbort)
                         break;
                     const sessionId = file.replace(/\.jsonl.*$/, "");
-                    const filePath = node_path_1.default.join(sessionsDir, file);
-                    send("progress", { total: totalMsgs, processed: globalMsgIdx, phase: "sessions", file });
                     try {
                         const fileStream = node_fs_1.default.createReadStream(filePath, { encoding: "utf-8" });
                         const rl = node_readline_1.default.createInterface({ input: fileStream, crlfDelay: Infinity });
@@ -1406,20 +1594,18 @@ class ViewerServer {
                             }
                             if (!content || content.length < 10)
                                 continue;
-                            globalMsgIdx++;
+                            const idx = incIdx();
                             totalProcessed++;
                             const sessionKey = `openclaw-session-${sessionId}`;
                             if (this.store.chunkExistsByContent(sessionKey, msgRole, content)) {
                                 totalSkipped++;
-                                send("item", {
-                                    index: globalMsgIdx,
-                                    total: totalMsgs,
-                                    status: "skipped",
-                                    preview: content.slice(0, 120),
-                                    source: file,
-                                    role: msgRole,
-                                    reason: "duplicate",
-                                });
+                                send("item", { index: idx, total: totalMsgs, status: "skipped", preview: content.slice(0, 120), source: file, agent: agentId, role: msgRole, reason: "duplicate" });
+                                continue;
+                            }
+                            const existingByHash = this.store.findActiveChunkByHash(content, agentOwner);
+                            if (existingByHash) {
+                                totalSkipped++;
+                                send("item", { index: idx, total: totalMsgs, status: "skipped", preview: content.slice(0, 120), source: file, agent: agentId, role: msgRole, reason: "exact duplicate within agent" });
                                 continue;
                             }
                             try {
@@ -1435,11 +1621,13 @@ class ViewerServer {
                                 let dedupTarget = null;
                                 let dedupReason = null;
                                 if (embedding) {
-                                    const topSimilar = (0, dedup_1.findTopSimilar)(this.store, embedding, 0.85, 3, this.log);
+                                    const importThreshold = this.ctx?.config?.dedup?.similarityThreshold ?? 0.60;
+                                    const dedupOwnerFilter = [agentOwner];
+                                    const topSimilar = (0, dedup_1.findTopSimilar)(this.store, embedding, importThreshold, 5, this.log, dedupOwnerFilter);
                                     if (topSimilar.length > 0) {
-                                        const candidates = topSimilar.map((s, idx) => {
+                                        const candidates = topSimilar.map((s, i) => {
                                             const chunk = this.store.getChunk(s.chunkId);
-                                            return { index: idx + 1, summary: chunk?.summary ?? "", chunkId: s.chunkId };
+                                            return { index: i + 1, summary: chunk?.summary ?? "", chunkId: s.chunkId };
                                         }).filter(c => c.summary);
                                         if (candidates.length > 0) {
                                             const dedupResult = await summarizer.judgeDedup(summary, candidates);
@@ -1473,60 +1661,55 @@ class ViewerServer {
                                 const msgTs = obj.message?.timestamp ?? obj.timestamp;
                                 const ts = msgTs ? new Date(msgTs).getTime() : Date.now();
                                 const chunk = {
-                                    id: chunkId,
-                                    sessionKey,
-                                    turnId: `import-${sessionId}-${globalMsgIdx}`,
-                                    seq: 0,
-                                    role: msgRole,
-                                    content,
-                                    kind: "paragraph",
-                                    summary,
-                                    embedding: null,
-                                    taskId: null,
-                                    skillId: null,
-                                    owner: "agent:main",
-                                    dedupStatus,
-                                    dedupTarget,
-                                    dedupReason,
-                                    mergeCount: 0,
-                                    lastHitAt: null,
-                                    mergeHistory: "[]",
-                                    createdAt: ts,
-                                    updatedAt: ts,
+                                    id: chunkId, sessionKey, turnId: `import-${agentId}-${sessionId}-${idx}`, seq: 0,
+                                    role: msgRole, content, kind: "paragraph", summary, embedding: null,
+                                    taskId: null, skillId: null, owner: agentOwner, dedupStatus, dedupTarget, dedupReason,
+                                    mergeCount: 0, lastHitAt: null, mergeHistory: "[]", createdAt: ts, updatedAt: ts,
                                 };
                                 this.store.insertChunk(chunk);
-                                if (embedding && dedupStatus === "active") {
+                                if (embedding && dedupStatus === "active")
                                     this.store.upsertEmbedding(chunkId, embedding);
-                                }
                                 totalStored++;
-                                send("item", {
-                                    index: globalMsgIdx,
-                                    total: totalMsgs,
-                                    status: dedupStatus === "active" ? "stored" : dedupStatus,
-                                    preview: content.slice(0, 120),
-                                    summary: summary.slice(0, 80),
-                                    source: file,
-                                    role: msgRole,
-                                });
+                                send("item", { index: idx, total: totalMsgs, status: dedupStatus === "active" ? "stored" : dedupStatus, preview: content.slice(0, 120), summary: summary.slice(0, 80), source: file, agent: agentId, role: msgRole });
                             }
                             catch (err) {
                                 totalErrors++;
-                                send("item", {
-                                    index: globalMsgIdx,
-                                    total: totalMsgs,
-                                    status: "error",
-                                    preview: content.slice(0, 120),
-                                    source: file,
-                                    error: String(err).slice(0, 200),
-                                });
+                                send("item", { index: idx, total: totalMsgs, status: "error", preview: content.slice(0, 120), source: file, agent: agentId, error: String(err).slice(0, 200) });
                             }
                         }
                     }
                     catch (err) {
-                        send("error", { file, error: String(err) });
+                        send("error", { file, agent: agentId, error: String(err) });
                         totalErrors++;
                     }
                 }
+            };
+            // Execute agents with concurrency control
+            const agentEntries = Array.from(agentGroups.entries());
+            if (concurrency <= 1 || agentEntries.length <= 1) {
+                for (const [agentId, files] of agentEntries) {
+                    if (this.migrationAbort)
+                        break;
+                    send("progress", { total: totalMsgs, processed: globalMsgIdx, phase: "sessions", agent: agentId });
+                    await importAgent(agentId, files);
+                }
+            }
+            else {
+                // Parallel: run up to `concurrency` agents at once
+                let cursor = 0;
+                const runBatch = async () => {
+                    while (cursor < agentEntries.length && !this.migrationAbort) {
+                        const batch = [];
+                        const batchStart = cursor;
+                        while (batch.length < concurrency && cursor < agentEntries.length) {
+                            const [agentId, files] = agentEntries[cursor++];
+                            send("progress", { total: totalMsgs, processed: globalMsgIdx, phase: "sessions", agent: agentId, parallel: true });
+                            batch.push(importAgent(agentId, files));
+                        }
+                        await Promise.all(batch);
+                    }
+                };
+                await runBatch();
             }
         }
         send("progress", { total: totalProcessed, processed: totalProcessed, phase: "done" });
@@ -1550,6 +1733,7 @@ class ViewerServer {
                 opts = JSON.parse(body);
             }
             catch { /* defaults */ }
+            const concurrency = Math.max(1, Math.min(opts.concurrency ?? 1, 8));
             res.writeHead(200, {
                 "Content-Type": "text/event-stream",
                 "Cache-Control": "no-cache",
@@ -1564,7 +1748,7 @@ class ViewerServer {
                 this.broadcastPPSSE(event, data);
             };
             this.ppRunning = true;
-            this.runPostprocess(send, !!opts.enableTasks, !!opts.enableSkills).finally(() => {
+            this.runPostprocess(send, !!opts.enableTasks, !!opts.enableSkills, concurrency).finally(() => {
                 this.ppRunning = false;
                 this.ppState.running = false;
                 this.ppState.done = true;
@@ -1623,126 +1807,148 @@ class ViewerServer {
             catch { /* */ }
         }
     }
-    async runPostprocess(send, enableTasks, enableSkills) {
+    async runPostprocess(send, enableTasks, enableSkills, concurrency = 1) {
         const ctx = this.ctx;
-        const taskProcessor = new task_processor_1.TaskProcessor(this.store, ctx);
-        let skillEvolver = null;
-        if (enableSkills) {
-            const recallEngine = new engine_1.RecallEngine(this.store, this.embedder, ctx);
-            skillEvolver = new evolver_1.SkillEvolver(this.store, recallEngine, ctx);
-            taskProcessor.onTaskCompleted(async (task) => {
-                try {
-                    await skillEvolver.onTaskCompleted(task);
-                    this.ppState.skillsCreated++;
-                    send("skill", { taskId: task.id, title: task.title });
-                }
-                catch (err) {
-                    this.log.warn(`Postprocess skill evolution error: ${err}`);
-                }
-            });
-        }
         const importSessions = this.store.getDistinctSessionKeys()
             .filter((sk) => sk.startsWith("openclaw-import-") || sk.startsWith("openclaw-session-"));
         const pendingItems = [];
         let skippedCount = 0;
+        const ownerMap = this.store.getSessionOwnerMap(importSessions);
         for (const sk of importSessions) {
             const hasTask = this.store.hasTaskForSession(sk);
             const hasSkill = this.store.hasSkillForSessionTask(sk);
+            const owner = ownerMap.get(sk) ?? "agent:main";
             if (enableTasks && !hasTask) {
-                pendingItems.push({ sessionKey: sk, action: "full" });
+                pendingItems.push({ sessionKey: sk, action: "full", owner });
             }
             else if (enableSkills && hasTask && !hasSkill) {
-                pendingItems.push({ sessionKey: sk, action: "skill-only" });
+                pendingItems.push({ sessionKey: sk, action: "skill-only", owner });
             }
             else {
                 skippedCount++;
             }
         }
+        // Group pending items by agent (owner)
+        const agentGroups = new Map();
+        for (const item of pendingItems) {
+            const group = agentGroups.get(item.owner) ?? [];
+            group.push(item);
+            agentGroups.set(item.owner, group);
+        }
         this.ppState.total = pendingItems.length;
         send("info", {
             totalSessions: importSessions.length,
             alreadyProcessed: skippedCount,
             pending: pendingItems.length,
+            agents: Array.from(agentGroups.keys()),
+            concurrency,
         });
         send("progress", { processed: 0, total: pendingItems.length });
-        for (let i = 0; i < pendingItems.length; i++) {
-            if (this.ppAbort)
-                break;
-            const { sessionKey, action } = pendingItems[i];
-            this.ppState.processed = i + 1;
-            send("item", {
-                index: i + 1,
-                total: pendingItems.length,
-                session: sessionKey,
-                step: "processing",
-                action,
-            });
-            try {
-                if (action === "full") {
-                    await taskProcessor.onChunksIngested(sessionKey, Date.now());
-                    const activeTask = this.store.getActiveTask(sessionKey);
-                    if (activeTask) {
-                        await taskProcessor.finalizeTask(activeTask);
-                        const finalized = this.store.getTask(activeTask.id);
-                        this.ppState.tasksCreated++;
-                        send("item", {
-                            index: i + 1,
-                            total: pendingItems.length,
-                            session: sessionKey,
-                            step: "done",
-                            taskTitle: finalized?.title || "",
-                            taskStatus: finalized?.status || "",
-                        });
+        let globalIdx = 0;
+        const incIdx = () => ++globalIdx;
+        // Process one agent's sessions sequentially
+        const processAgent = async (agentOwner, items) => {
+            const taskProcessor = new task_processor_1.TaskProcessor(this.store, ctx);
+            let skillEvolver = null;
+            if (enableSkills) {
+                const recallEngine = new engine_1.RecallEngine(this.store, this.embedder, ctx);
+                skillEvolver = new evolver_1.SkillEvolver(this.store, recallEngine, ctx);
+                taskProcessor.onTaskCompleted(async (task) => {
+                    try {
+                        await skillEvolver.onTaskCompleted(task);
+                        this.ppState.skillsCreated++;
+                        send("skill", { taskId: task.id, title: task.title, agent: agentOwner });
                     }
-                    else {
-                        send("item", {
-                            index: i + 1,
-                            total: pendingItems.length,
-                            session: sessionKey,
-                            step: "done",
-                            taskTitle: "(no chunks)",
-                        });
+                    catch (err) {
+                        this.log.warn(`Postprocess skill evolution error (${agentOwner}): ${err}`);
                     }
-                }
-                else if (action === "skill-only" && skillEvolver) {
-                    const completedTasks = this.store.getCompletedTasksForSession(sessionKey);
-                    let skillGenerated = false;
-                    for (const task of completedTasks) {
-                        if (this.ppAbort)
-                            break;
-                        try {
-                            await skillEvolver.onTaskCompleted(task);
-                            this.ppState.skillsCreated++;
-                            skillGenerated = true;
-                            send("skill", { taskId: task.id, title: task.title });
+                });
+            }
+            for (const { sessionKey, action } of items) {
+                if (this.ppAbort)
+                    break;
+                const idx = incIdx();
+                this.ppState.processed = globalIdx;
+                send("item", {
+                    index: idx,
+                    total: pendingItems.length,
+                    session: sessionKey,
+                    agent: agentOwner,
+                    step: "processing",
+                    action,
+                });
+                try {
+                    if (action === "full") {
+                        await taskProcessor.onChunksIngested(sessionKey, Date.now());
+                        const activeTask = this.store.getActiveTask(sessionKey);
+                        if (activeTask) {
+                            await taskProcessor.finalizeTask(activeTask);
+                            const finalized = this.store.getTask(activeTask.id);
+                            this.ppState.tasksCreated++;
+                            send("item", {
+                                index: idx, total: pendingItems.length, session: sessionKey, agent: agentOwner,
+                                step: "done", taskTitle: finalized?.title || "", taskStatus: finalized?.status || "",
+                            });
+                        }
+                        else {
+                            send("item", {
+                                index: idx, total: pendingItems.length, session: sessionKey, agent: agentOwner,
+                                step: "done", taskTitle: "(no chunks)",
+                            });
                         }
-                        catch (err) {
-                            this.log.warn(`Skill evolution error for task=${task.id}: ${err}`);
+                    }
+                    else if (action === "skill-only" && skillEvolver) {
+                        const completedTasks = this.store.getCompletedTasksForSession(sessionKey);
+                        let skillGenerated = false;
+                        for (const task of completedTasks) {
+                            if (this.ppAbort)
+                                break;
+                            try {
+                                await skillEvolver.onTaskCompleted(task);
+                                this.ppState.skillsCreated++;
+                                skillGenerated = true;
+                                send("skill", { taskId: task.id, title: task.title, agent: agentOwner });
+                            }
+                            catch (err) {
+                                this.log.warn(`Skill evolution error (${agentOwner}) task=${task.id}: ${err}`);
+                            }
                         }
+                        send("item", {
+                            index: idx, total: pendingItems.length, session: sessionKey, agent: agentOwner,
+                            step: "done", taskTitle: completedTasks[0]?.title || sessionKey, action: "skill-only", skillGenerated,
+                        });
                     }
+                }
+                catch (err) {
+                    this.ppState.errors++;
+                    this.log.warn(`Postprocess error (${agentOwner}) ${sessionKey}: ${err}`);
                     send("item", {
-                        index: i + 1,
-                        total: pendingItems.length,
-                        session: sessionKey,
-                        step: "done",
-                        taskTitle: completedTasks[0]?.title || sessionKey,
-                        action: "skill-only",
-                        skillGenerated,
+                        index: idx, total: pendingItems.length, session: sessionKey, agent: agentOwner,
+                        step: "error", error: String(err).slice(0, 200),
                     });
                 }
+                send("progress", { processed: globalIdx, total: pendingItems.length });
             }
-            catch (err) {
-                this.ppState.errors++;
-                this.log.warn(`Postprocess error for ${sessionKey}: ${err}`);
-                send("item", {
-                    index: i + 1,
-                    total: pendingItems.length,
-                    session: sessionKey,
-                    step: "error",
-                    error: String(err).slice(0, 200),
-                });
+        };
+        // Execute agents with concurrency control
+        const agentEntries = Array.from(agentGroups.entries());
+        if (concurrency <= 1 || agentEntries.length <= 1) {
+            for (const [agentOwner, items] of agentEntries) {
+                if (this.ppAbort)
+                    break;
+                await processAgent(agentOwner, items);
+            }
+        }
+        else {
+            let cursor = 0;
+            while (cursor < agentEntries.length && !this.ppAbort) {
+                const batch = [];
+                while (batch.length < concurrency && cursor < agentEntries.length) {
+                    const [agentOwner, items] = agentEntries[cursor++];
+                    batch.push(processAgent(agentOwner, items));
+                }
+                await Promise.all(batch);
             }
-            send("progress", { processed: i + 1, total: pendingItems.length });
         }
     }
     readBody(req, cb) {