@memtensor/memos-local-openclaw-plugin 1.0.8-beta.2 → 1.0.8-beta.3

package/src/ingest/task-processor.ts

@@ -51,6 +51,9 @@ export class TaskProcessor {
    * Determines if a new task boundary was crossed and handles transition.
    */
   async onChunksIngested(sessionKey: string, latestTimestamp: number, owner?: string): Promise<void> {
+    if (sessionKey.startsWith("temp:") || sessionKey.startsWith("internal:") || sessionKey.startsWith("system:")) {
+      return;
+    }
     const resolvedOwner = owner ?? "agent:main";
     this.ctx.log.debug(`TaskProcessor.onChunksIngested called session=${sessionKey} ts=${latestTimestamp} owner=${resolvedOwner} processing=${this.processing}`);
     this.pendingEvents.push({ sessionKey, latestTimestamp, owner: resolvedOwner });
@@ -79,13 +82,19 @@ export class TaskProcessor {
     }
   }
 
+  private static extractAgentPrefix(sessionKey: string): string {
+    const parts = sessionKey.split(":");
+    return parts.length >= 3 ? parts.slice(0, 3).join(":") : sessionKey;
+  }
+
   private async detectAndProcess(sessionKey: string, latestTimestamp: number, owner: string): Promise<void> {
     this.ctx.log.debug(`TaskProcessor.detectAndProcess session=${sessionKey} owner=${owner}`);
 
+    const currentAgentPrefix = TaskProcessor.extractAgentPrefix(sessionKey);
     const allActive = this.store.getAllActiveTasks(owner);
     for (const t of allActive) {
-      if (t.sessionKey !== sessionKey) {
-        this.ctx.log.info(`Session changed: finalizing task=${t.id} from session=${t.sessionKey} (owner=${owner})`);
+      if (t.sessionKey !== sessionKey && TaskProcessor.extractAgentPrefix(t.sessionKey) === currentAgentPrefix) {
+        this.ctx.log.info(`Session changed within agent: finalizing task=${t.id} from session=${t.sessionKey} (owner=${owner})`);
         await this.finalizeTask(t);
       }
     }
@@ -179,26 +188,36 @@ export class TaskProcessor {
         continue;
       }
 
-      // LLM topic judgment — check this single user message against full task context
-      const context = this.buildContextSummary(currentTaskChunks);
+      // Structured topic classification
+      const taskState = this.buildTopicJudgeState(currentTaskChunks, userChunk);
       const newMsg = userChunk.content.slice(0, 500);
-      this.ctx.log.info(`Topic judge: "${newMsg.slice(0, 60)}" vs ${existingUserCount} user turns`);
-      const isNew = await this.summarizer.judgeNewTopic(context, newMsg);
-      this.ctx.log.info(`Topic judge result: ${isNew === null ? "null(fallback)" : isNew ? "NEW" : "SAME"}`);
+      this.ctx.log.info(`Topic classify: "${newMsg.slice(0, 60)}" vs ${existingUserCount} user turns`);
+      const result = await this.summarizer.classifyTopic(taskState, newMsg);
+      this.ctx.log.info(`Topic classify: decision=${result?.decision ?? "null"} confidence=${result?.confidence ?? "?"} type=${result?.boundaryType ?? "?"} reason=${result?.reason ?? ""}`);
 
-      if (isNew === null) {
+      if (!result || result.decision === "SAME") {
         this.assignChunksToTask(turn, currentTask.id);
         currentTaskChunks = currentTaskChunks.concat(turn);
         continue;
       }
 
-      if (isNew) {
-        this.ctx.log.info(`Task boundary at turn ${i}: LLM judged new topic. Msg: "${newMsg.slice(0, 80)}..."`);
-        await this.finalizeTask(currentTask);
-        currentTask = await this.createNewTaskReturn(sessionKey, userChunk.createdAt, owner);
-        currentTaskChunks = [];
+      // Low-confidence NEW: second-pass arbitration
+      if (result.confidence < 0.65) {
+        this.ctx.log.info(`Low confidence NEW (${result.confidence}), running second-pass arbitration...`);
+        const secondResult = await this.summarizer.arbitrateTopicSplit(taskState, newMsg);
+        this.ctx.log.info(`Second-pass result: ${secondResult ?? "null(fallback->SAME)"}`);
+        if (!secondResult || secondResult !== "NEW") {
+          this.assignChunksToTask(turn, currentTask.id);
+          currentTaskChunks = currentTaskChunks.concat(turn);
+          continue;
+        }
       }
 
+      this.ctx.log.info(`Task boundary at turn ${i}: classifier judged NEW (confidence=${result.confidence}). Msg: "${newMsg.slice(0, 80)}..."`);
+      await this.finalizeTask(currentTask);
+      currentTask = await this.createNewTaskReturn(sessionKey, userChunk.createdAt, owner);
+      currentTaskChunks = [];
+
       this.assignChunksToTask(turn, currentTask.id);
       currentTaskChunks = currentTaskChunks.concat(turn);
     }
@@ -226,38 +245,39 @@ export class TaskProcessor {
   }
 
   /**
-   * Build context from existing task chunks for the LLM topic judge.
-   * Includes both the task's opening topic and recent exchanges,
-   * so the LLM understands both what the task was originally about
-   * and where the conversation currently is.
-   *
-   * For user messages, include full content (up to 500 chars) since
-   * they carry the topic signal. For assistant messages, use summary
-   * or truncated content since they mostly elaborate.
+   * Build compact task state for the LLM topic classifier.
+   * Includes: topic (first user msg), last 3 turn summaries,
+   * and optional assistant snippet for short/ambiguous messages.
    */
-  private buildContextSummary(chunks: Chunk[]): string {
-    const conversational = chunks.filter((c) => c.role === "user" || c.role === "assistant");
-    if (conversational.length === 0) return "";
-
-    const formatChunk = (c: Chunk) => {
-      const label = c.role === "user" ? "User" : "Assistant";
-      const maxLen = c.role === "user" ? 500 : 200;
-      const text = c.summary || c.content.slice(0, maxLen);
-      return `[${label}]: ${text}`;
-    };
+  private buildTopicJudgeState(chunks: Chunk[], newUserChunk: Chunk): string {
+    const conv = chunks.filter((c) => c.role === "user" || c.role === "assistant");
+    if (conv.length === 0) return "";
+
+    const firstUser = conv.find((c) => c.role === "user");
+    const topic = firstUser?.summary || firstUser?.content.slice(0, 80) || "";
+
+    const turns: Array<{ u: string; a: string }> = [];
+    for (let j = 0; j < conv.length; j++) {
+      if (conv[j].role === "user") {
+        const u = conv[j].summary || conv[j].content.slice(0, 60);
+        const nextA = conv[j + 1]?.role === "assistant" ? conv[j + 1] : null;
+        const a = nextA ? (nextA.summary || nextA.content.slice(0, 60)) : "";
+        turns.push({ u, a });
+      }
+    }
+
+    const recent = turns.slice(-3);
+    const turnLines = recent.map((t, i) => `${i + 1}. U:${t.u} A:${t.a}`);
 
-    if (conversational.length <= 10) {
-      return conversational.map(formatChunk).join("\n");
+    let snippet = "";
+    if (newUserChunk.content.length < 30 || /^[那这它其还哪啥]/.test(newUserChunk.content.trim())) {
+      const lastA = [...conv].reverse().find((c) => c.role === "assistant");
+      if (lastA) snippet = lastA.content.slice(0, 200);
     }
 
-    const opening = conversational.slice(0, 6).map(formatChunk);
-    const recent = conversational.slice(-4).map(formatChunk);
-    return [
-      "--- Task opening ---",
-      ...opening,
-      "--- Recent exchanges ---",
-      ...recent,
-    ].join("\n");
+    const parts = [`topic:${topic}`, ...turnLines];
+    if (snippet) parts.push(`lastA:${snippet}`);
+    return parts.join("\n");
   }
 
   private async createNewTaskReturn(sessionKey: string, timestamp: number, owner: string = "agent:main"): Promise<Task> {

package/src/ingest/worker.ts

@@ -25,8 +25,14 @@ export class IngestWorker {
 
   getTaskProcessor(): TaskProcessor { return this.taskProcessor; }
 
+  private static isEphemeralSession(sessionKey: string): boolean {
+    return sessionKey.startsWith("temp:") || sessionKey.startsWith("internal:") || sessionKey.startsWith("system:");
+  }
+
   enqueue(messages: ConversationMessage[]): void {
-    this.queue.push(...messages);
+    const filtered = messages.filter((m) => !IngestWorker.isEphemeralSession(m.sessionKey));
+    if (filtered.length === 0) return;
+    this.queue.push(...filtered);
     if (!this.processing) {
       this.processQueue().catch((err) => {
         this.ctx.log.error(`Ingest worker error: ${err}`);
@@ -150,14 +156,23 @@ export class IngestWorker {
     let mergeHistory = "[]";
 
     // Fast path: exact content_hash match within same owner (agent dimension)
+    // Strategy: retire the OLD chunk, keep the NEW one active (latest wins)
     const chunkOwner = msg.owner ?? "agent:main";
     const existingByHash = this.store.findActiveChunkByHash(content, chunkOwner);
     if (existingByHash) {
-      this.ctx.log.debug(`Exact-dup (owner=${chunkOwner}): hash match → existing=${existingByHash}`);
+      this.ctx.log.debug(`Exact-dup (owner=${chunkOwner}): hash match → retiring old=${existingByHash}, keeping new=${chunkId}`);
       this.store.recordMergeHit(existingByHash, "DUPLICATE", "exact content hash match");
-      dedupStatus = "duplicate";
-      dedupTarget = existingByHash;
+      const oldChunk = this.store.getChunk(existingByHash);
+      this.store.markDedupStatus(existingByHash, "duplicate", chunkId, "exact content hash match");
+      this.store.deleteEmbedding(existingByHash);
+      mergedFromOld = existingByHash;
       dedupReason = "exact content hash match";
+      if (oldChunk) {
+        const oldHistory = JSON.parse(oldChunk.mergeHistory || "[]");
+        oldHistory.push({ action: "duplicate_superseded", at: Date.now(), reason: "exact content hash match", sourceChunkId: existingByHash });
+        mergeHistory = JSON.stringify(oldHistory);
+        mergeCount = (oldChunk.mergeCount || 0) + 1;
+      }
     }
 
     // Smart dedup: find Top-5 similar chunks, then ask LLM to judge
@@ -173,8 +188,9 @@ export class IngestWorker {
             index: i + 1,
             summary: chunk?.summary ?? "",
             chunkId: s.chunkId,
+            role: chunk?.role,
           };
-        }).filter(c => c.summary);
+        }).filter(c => c.summary && c.role === msg.role);
 
         if (candidates.length > 0) {
           const dedupResult = await this.summarizer.judgeDedup(summary, candidates);
@@ -183,10 +199,18 @@ export class IngestWorker {
             const targetChunkId = candidates[dedupResult.targetIndex - 1]?.chunkId;
             if (targetChunkId) {
               this.store.recordMergeHit(targetChunkId, "DUPLICATE", dedupResult.reason);
-              dedupStatus = "duplicate";
-              dedupTarget = targetChunkId;
+              const oldChunk = this.store.getChunk(targetChunkId);
+              this.store.markDedupStatus(targetChunkId, "duplicate", chunkId, dedupResult.reason);
+              this.store.deleteEmbedding(targetChunkId);
+              mergedFromOld = targetChunkId;
               dedupReason = dedupResult.reason;
-              this.ctx.log.debug(`Smart dedup: DUPLICATE → target=${targetChunkId}, storing with status=duplicate, reason: ${dedupResult.reason}`);
+              if (oldChunk) {
+                const oldHistory = JSON.parse(oldChunk.mergeHistory || "[]");
+                oldHistory.push({ action: "duplicate_superseded", at: Date.now(), reason: dedupResult.reason, sourceChunkId: targetChunkId });
+                mergeHistory = JSON.stringify(oldHistory);
+                mergeCount = (oldChunk.mergeCount || 0) + 1;
+              }
+              this.ctx.log.debug(`Smart dedup: DUPLICATE → retiring old=${targetChunkId}, keeping new=${chunkId} active, reason: ${dedupResult.reason}`);
             }
           }
 
@@ -266,9 +290,6 @@ export class IngestWorker {
     }
     this.ctx.log.debug(`Stored chunk=${chunkId} kind=${kind} role=${msg.role} dedup=${dedupStatus} len=${content.length} hasVec=${!!embedding && dedupStatus === "active"}`);
 
-    if (dedupStatus === "duplicate") {
-      return { action: "duplicate", summary, targetChunkId: dedupTarget ?? undefined, reason: dedupReason ?? undefined };
-    }
     if (mergedFromOld) {
       return { action: "merged", chunkId, summary, targetChunkId: mergedFromOld, reason: dedupReason ?? undefined };
     }

package/src/recall/engine.ts

@@ -234,6 +234,7 @@ export class RecallEngine {
         score: Math.round(candidate.score * 1000) / 1000,
         taskId: chunk.taskId,
         skillId: chunk.skillId,
+        owner: chunk.owner,
         origin: chunk.owner === "public" ? "local-shared" : "local",
         source: {
           ts: chunk.createdAt,

package/src/sharing/types.ts

@@ -38,6 +38,7 @@ export interface HubSearchHit {
   hubRank: number;
   taskTitle: string | null;
   ownerName: string;
+  sourceAgent: string;
   groupName: string | null;
   visibility: SharedVisibility;
   source: {

package/src/storage/sqlite.ts

@@ -110,10 +110,12 @@ export class SqliteStore {
     this.migrateOwnerFields();
     this.migrateSkillVisibility();
     this.migrateSkillEmbeddingsAndFts();
+    this.migrateTaskTopicColumn();
     this.migrateTaskEmbeddingsAndFts();
     this.migrateFtsToTrigram();
     this.migrateHubTables();
     this.migrateHubFtsToTrigram();
+    this.migrateHubMemorySourceAgent();
     this.migrateLocalSharedTasksOwner();
     this.migrateHubUserIdentityFields();
     this.migrateClientHubConnectionIdentityFields();
@@ -125,6 +127,16 @@ export class SqliteStore {
     this.db.exec("CREATE INDEX IF NOT EXISTS idx_chunks_dedup_created ON chunks(dedup_status, created_at DESC)");
   }
 
+  private migrateHubMemorySourceAgent(): void {
+    try {
+      const cols = this.db.prepare("PRAGMA table_info(hub_memories)").all() as Array<{ name: string }>;
+      if (cols.length > 0 && !cols.some((c) => c.name === "source_agent")) {
+        this.db.exec("ALTER TABLE hub_memories ADD COLUMN source_agent TEXT NOT NULL DEFAULT ''");
+        this.log.info("Migrated: added source_agent column to hub_memories");
+      }
+    } catch { /* table may not exist yet */ }
+  }
+
   private migrateLocalSharedTasksOwner(): void {
     try {
       const cols = this.db.prepare("PRAGMA table_info(local_shared_tasks)").all() as Array<{ name: string }>;
@@ -557,6 +569,14 @@ export class SqliteStore {
     }
   }
 
+  private migrateTaskTopicColumn(): void {
+    const cols = this.db.prepare("PRAGMA table_info(tasks)").all() as Array<{ name: string }>;
+    if (!cols.some((c) => c.name === "topic")) {
+      this.db.exec("ALTER TABLE tasks ADD COLUMN topic TEXT DEFAULT NULL");
+      this.log.info("Migrated: added topic column to tasks");
+    }
+  }
+
   private migrateTaskSkillMeta(): void {
     const cols = this.db.prepare("PRAGMA table_info(tasks)").all() as Array<{ name: string }>;
     if (!cols.some((c) => c.name === "skill_status")) {
@@ -1042,6 +1062,7 @@ export class SqliteStore {
         id              TEXT PRIMARY KEY,
         source_chunk_id TEXT NOT NULL,
         source_user_id  TEXT NOT NULL,
+        source_agent    TEXT NOT NULL DEFAULT '',
         role            TEXT NOT NULL,
         content         TEXT NOT NULL,
         summary         TEXT NOT NULL DEFAULT '',
@@ -1483,8 +1504,15 @@ export class SqliteStore {
 
   deleteAll(): number {
     this.db.exec("PRAGMA foreign_keys = OFF");
+    try {
+      this.db.exec("DROP TRIGGER IF EXISTS tasks_fts_ai");
+      this.db.exec("DROP TRIGGER IF EXISTS tasks_fts_ad");
+      this.db.exec("DROP TRIGGER IF EXISTS tasks_fts_au");
+      this.db.exec("DELETE FROM tasks_fts");
+    } catch (_) {}
     const tables = [
       "task_skills",
+      "task_embeddings",
       "skill_embeddings",
       "skill_versions",
       "skills",
@@ -1507,6 +1535,7 @@ export class SqliteStore {
       }
     }
     this.db.exec("PRAGMA foreign_keys = ON");
+    this.migrateTaskEmbeddingsAndFts();
     const remaining = this.countChunks();
     return remaining === 0 ? 1 : 0;
   }
@@ -2574,9 +2603,10 @@ export class SqliteStore {
 
   upsertHubMemory(memory: HubMemoryRecord): void {
     this.db.prepare(`
-      INSERT INTO hub_memories (id, source_chunk_id, source_user_id, role, content, summary, kind, group_id, visibility, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO hub_memories (id, source_chunk_id, source_user_id, source_agent, role, content, summary, kind, group_id, visibility, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(source_user_id, source_chunk_id) DO UPDATE SET
+        source_agent = excluded.source_agent,
         role = excluded.role,
         content = excluded.content,
         summary = excluded.summary,
@@ -2585,7 +2615,7 @@ export class SqliteStore {
         visibility = excluded.visibility,
         created_at = excluded.created_at,
         updated_at = excluded.updated_at
-    `).run(memory.id, memory.sourceChunkId, memory.sourceUserId, memory.role, memory.content, memory.summary, memory.kind, memory.groupId, memory.visibility, memory.createdAt, memory.updatedAt);
+    `).run(memory.id, memory.sourceChunkId, memory.sourceUserId, memory.sourceAgent, memory.role, memory.content, memory.summary, memory.kind, memory.groupId, memory.visibility, memory.createdAt, memory.updatedAt);
   }
 
   getHubMemoryBySource(sourceUserId: string, sourceChunkId: string): HubMemoryRecord | null {
@@ -2751,7 +2781,7 @@ export class SqliteStore {
     if (!sanitized) return [];
     const rows = this.db.prepare(`
       SELECT hm.id, hm.content, hm.summary, hm.role, hm.created_at, hm.visibility, '' as group_name, hu.username as owner_name,
-             bm25(hub_memories_fts) as rank
+             COALESCE(hm.source_agent, '') as source_agent, bm25(hub_memories_fts) as rank
       FROM hub_memories_fts f
       JOIN hub_memories hm ON hm.rowid = f.rowid
       LEFT JOIN hub_users hu ON hu.id = hm.source_user_id
@@ -2767,7 +2797,7 @@ export class SqliteStore {
   getVisibleHubSearchHitByMemoryId(memoryId: string, userId: string): HubMemorySearchRow | null {
     const row = this.db.prepare(`
       SELECT hm.id, hm.content, hm.summary, hm.role, hm.created_at, hm.visibility, '' as group_name, hu.username as owner_name,
-             0 as rank
+             COALESCE(hm.source_agent, '') as source_agent, 0 as rank
       FROM hub_memories hm
       LEFT JOIN hub_users hu ON hu.id = hm.source_user_id
       WHERE hm.id = ?
@@ -3261,6 +3291,7 @@ export interface HubMemoryRecord {
   id: string;
   sourceChunkId: string;
   sourceUserId: string;
+  sourceAgent: string;
   role: string;
   content: string;
   summary: string;
@@ -3275,6 +3306,7 @@ interface HubMemoryRow {
   id: string;
   source_chunk_id: string;
   source_user_id: string;
+  source_agent: string;
   role: string;
   content: string;
   summary: string;
@@ -3290,6 +3322,7 @@ function rowToHubMemory(row: HubMemoryRow): HubMemoryRecord {
     id: row.id,
     sourceChunkId: row.source_chunk_id,
     sourceUserId: row.source_user_id,
+    sourceAgent: row.source_agent || "",
     role: row.role,
     content: row.content,
     summary: row.summary,
@@ -3310,6 +3343,7 @@ interface HubMemorySearchRow {
   visibility: string;
   group_name: string | null;
   owner_name: string | null;
+  source_agent: string;
   rank: number;
 }
 

package/src/types.ts

@@ -322,6 +322,8 @@ export interface MemosLocalConfig {
   skillEvolution?: SkillEvolutionConfig;
   telemetry?: TelemetryConfig;
   sharing?: SharingConfig;
+  /** Hours of inactivity after which an active task is automatically finalized. 0 = disabled. Default 4. */
+  taskAutoFinalizeHours?: number;
 }
 
 // ─── Defaults ───
@@ -357,6 +359,7 @@ export const DEFAULTS = {
   skillAutoRecallLimit: 2,
   skillPreferUpgrade: true,
   skillRedactSensitive: true,
+  taskAutoFinalizeHours: 4,
 } as const;
 
 // ─── Plugin Hooks (OpenClaw integration) ───