@clawmem-ai/clawmem 0.1.16 → 0.1.18

package/src/state.test.ts

@@ -36,13 +36,10 @@ async function testMigratesLegacyV2State(): Promise<void> {
   }, async (filePath) => {
     const state = await loadState(filePath);
     const session = state.sessions["main:s-1"];
-    assert(state.version === 3, "expected state version 3 after migration");
+    assert(state.version === 4, "expected state version 4 after migration");
     assert(Boolean(session), "expected migrated session to exist");
-    assert(session?.derived?.digest.cursor === 0, "expected legacy sessions to rebuild digest from cursor 0");
-    assert(session?.derived?.digest.status === "pending", "expected digest to become pending after migration");
-    assert(session?.derived?.summary.status === "pending", "expected finalized legacy sessions to keep summary pending");
-    assert(session?.derived?.memory.appliedCursor === 4, "expected legacy memory sync cursor to migrate into appliedCursor");
-    assert(session?.lastMemorySyncCount === 4, "expected compatibility field to mirror appliedCursor");
+    assert(session?.derived?.summary.status === "error", "expected finalized legacy sessions without a final summary to surface as needing manual attention");
+    assert(session?.derived?.memory.capturedCursor === 4, "expected legacy memory sync cursor to migrate into capturedCursor");
   });
 }
 
@@ -56,17 +53,12 @@ async function testNormalizesRunningTaskStates(): Promise<void> {
         lastMirroredCount: 3,
         turnCount: 3,
         derived: {
-          digest: { cursor: 1, status: "running", attempt: 2, text: "digest" },
           summary: { basedOnCursor: 0, status: "running" },
           memory: {
             extractCursor: 1,
             appliedCursor: 0,
             extractStatus: "running",
             reconcileStatus: "running",
-            attempt: 1,
-            pendingCandidates: [
-              { candidateId: "abc", detail: "Remember Redis is atomic with Lua." },
-            ],
           },
         },
       },
@@ -74,15 +66,54 @@ async function testNormalizesRunningTaskStates(): Promise<void> {
   }, async (filePath) => {
     const state = await loadState(filePath);
     const session = state.sessions["main:s-2"];
-    assert(session?.derived?.digest.status === "pending", "expected running digest tasks to normalize to pending on load");
-    assert(session?.derived?.summary.status === "pending", "expected running summary tasks to normalize to pending on load");
-    assert(session?.derived?.memory.extractStatus === "pending", "expected running memory extract tasks to normalize to pending");
-    assert(session?.derived?.memory.reconcileStatus === "pending", "expected running memory reconcile tasks to normalize to pending");
-    assert(session?.derived?.memory.pendingCandidates.length === 1, "expected pending candidates to survive state reload");
+    assert(session?.derived?.summary.status === "idle", "expected running summary tasks to normalize to idle on load");
+    assert(session?.derived?.memory.status === "idle", "expected running memory tasks to normalize to idle on load");
+    assert(session?.derived?.memory.capturedCursor === 0, "expected captured cursor to preserve the applied progress");
+  });
+}
+
+async function testPreservesCachedFinalArtifacts(): Promise<void> {
+  await withTempStateFile({
+    version: 4,
+    sessions: {
+      "main:s-3": {
+        sessionId: "s-3",
+        agentId: "main",
+        lastMirroredCount: 5,
+        turnCount: 5,
+        derived: {
+          summary: {
+            basedOnCursor: 5,
+            status: "idle",
+            text: "Recovered summary",
+            title: "Recovered title",
+          },
+          memory: {
+            capturedCursor: 0,
+            status: "error",
+            candidates: [
+              {
+                candidateId: "cand-1",
+                detail: "Store this durable fact.",
+                kind: "lesson",
+                topics: ["redis"],
+              },
+            ],
+          },
+        },
+      },
+    },
+  }, async (filePath) => {
+    const state = await loadState(filePath);
+    const session = state.sessions["main:s-3"];
+    assert(session?.derived?.summary.title === "Recovered title", "expected cached finalize title to survive state load");
+    assert(session?.derived?.memory.candidates?.length === 1, "expected cached memory candidates to survive state load");
+    assert(session?.derived?.memory.candidates?.[0]?.detail === "Store this durable fact.", "expected cached candidate detail to survive state load");
   });
 }
 
 await testMigratesLegacyV2State();
 await testNormalizesRunningTaskStates();
+await testPreservesCachedFinalArtifacts();
 
 console.log("state tests passed");

package/src/state.ts

@@ -4,7 +4,7 @@ import type { MemoryCandidate, PluginState, SessionDerivedState, SessionMirrorSt
 import { normalizeAgentId, sessionScopeKey } from "./utils.js";
 
 const EMPTY_STATE: PluginState = {
-  version: 3,
+  version: 4,
   sessions: {},
 };
 
@@ -38,10 +38,9 @@ function sanitizeState(value: unknown): PluginState {
     return structuredClone(EMPTY_STATE);
   }
   const raw = value as Record<string, unknown>;
-  const sessions =
-    raw.sessions && typeof raw.sessions === "object"
-      ? (raw.sessions as Record<string, unknown>)
-      : {};
+  const sessions = raw.sessions && typeof raw.sessions === "object"
+    ? (raw.sessions as Record<string, unknown>)
+    : {};
   const migrations: Record<string, string> = {};
   if (raw.migrations && typeof raw.migrations === "object") {
     for (const [k, v] of Object.entries(raw.migrations as Record<string, unknown>)) {
@@ -50,30 +49,19 @@ function sanitizeState(value: unknown): PluginState {
     }
   }
   const out: PluginState = {
-    version: 3,
+    version: 4,
     sessions: {},
     ...(Object.keys(migrations).length > 0 ? { migrations } : {}),
   };
   for (const [storedKey, sessionValue] of Object.entries(sessions)) {
-    if (!sessionValue || typeof sessionValue !== "object" || !storedKey.trim()) {
-      continue;
-    }
+    if (!sessionValue || typeof sessionValue !== "object" || !storedKey.trim()) continue;
     const rawSession = sessionValue as Record<string, unknown>;
     const sessionId = readString(rawSession.sessionId) ?? storedKey.trim();
-    if (!sessionId) {
-      continue;
-    }
+    if (!sessionId) continue;
     const agentId = normalizeAgentId(readString(rawSession.agentId));
     const lastMirroredCount = readNumber(rawSession.lastMirroredCount) ?? 0;
     const finalizedAt = readString(rawSession.finalizedAt);
-    const summaryStatus = readEnum(rawSession.summaryStatus, ["pending", "complete"]);
-    const lastMemorySyncCount = readNumber(rawSession.lastMemorySyncCount);
-    const derived = sanitizeDerivedState(rawSession.derived, {
-      lastMirroredCount,
-      finalizedAt,
-      summaryStatus,
-      lastMemorySyncCount,
-    });
+    const derived = sanitizeDerivedState(rawSession, lastMirroredCount, finalizedAt);
     out.sessions[sessionScopeKey(sessionId, agentId)] = {
       sessionId,
       sessionKey: readString(rawSession.sessionKey),
@@ -81,14 +69,11 @@ function sanitizeState(value: unknown): PluginState {
       agentId,
       issueNumber: readNumber(rawSession.issueNumber),
       issueTitle: readString(rawSession.issueTitle),
-      titleSource: readEnum(rawSession.titleSource, ["placeholder", "digest", "llm"]),
+      titleSource: readTitleSource(rawSession.titleSource),
       lastMirroredCount,
       turnCount: readNumber(rawSession.turnCount) ?? 0,
-      lastMemorySyncCount: derived.memory.appliedCursor,
-      summaryStatus: derived.summary.status === "complete" ? "complete" : finalizedAt ? "pending" : undefined,
       finalizedAt,
       lastSummaryHash: readString(rawSession.lastSummaryHash),
-      lastTurnHash: readString(rawSession.lastTurnHash),
       derived,
       createdAt: readString(rawSession.createdAt),
       updatedAt: readString(rawSession.updatedAt),
@@ -98,92 +83,62 @@ function sanitizeState(value: unknown): PluginState {
 }
 
 function sanitizeDerivedState(
-  value: unknown,
-  fallback: {
-    lastMirroredCount: number;
-    finalizedAt?: string;
-    summaryStatus?: "pending" | "complete";
-    lastMemorySyncCount?: number;
-  },
+  rawSession: Record<string, unknown>,
+  lastMirroredCount: number,
+  finalizedAt?: string,
 ): SessionDerivedState {
-  if (!value || typeof value !== "object") {
-    return migrateDerivedState(fallback);
-  }
-  const record = value as Record<string, unknown>;
-  const digest = asRecord(record.digest);
-  const summary = asRecord(record.summary);
-  const memory = asRecord(record.memory);
-  const lastMirroredCount = fallback.lastMirroredCount;
-  const extractCursor = clampCursor(readNumber(memory?.extractCursor), lastMirroredCount);
-  const appliedCursor = clampCursor(readNumber(memory?.appliedCursor), extractCursor);
-  return {
-    digest: {
-      cursor: clampCursor(readNumber(digest?.cursor), lastMirroredCount),
-      status: readTaskStatus(digest?.status, lastMirroredCount > 0 ? "pending" : "idle"),
-      attempt: readNumber(digest?.attempt) ?? 0,
-      text: readString(digest?.text),
-      title: readString(digest?.title),
-      lastError: readString(digest?.lastError),
-      updatedAt: readString(digest?.updatedAt),
-    },
-    summary: {
-      basedOnCursor: clampCursor(readNumber(summary?.basedOnCursor), lastMirroredCount),
-      status: readTaskStatus(summary?.status, fallback.finalizedAt ? "pending" : "idle"),
-      text: readString(summary?.text),
-      lastError: readString(summary?.lastError),
-      updatedAt: readString(summary?.updatedAt),
-    },
-    memory: {
-      extractCursor,
-      appliedCursor,
-      extractStatus: readTaskStatus(memory?.extractStatus, extractCursor < lastMirroredCount ? "pending" : "idle"),
-      reconcileStatus: readTaskStatus(memory?.reconcileStatus, appliedCursor < extractCursor ? "pending" : "idle"),
-      attempt: readNumber(memory?.attempt) ?? 0,
-      pendingCandidates: Array.isArray(memory?.pendingCandidates)
-        ? memory.pendingCandidates.map(sanitizeCandidate).filter((candidate): candidate is MemoryCandidate => Boolean(candidate))
-        : [],
-      lastError: readString(memory?.lastError),
-      updatedAt: readString(memory?.updatedAt),
-    },
-  };
-}
+  const rawDerived = asRecord(rawSession.derived);
+  const rawSummary = asRecord(rawDerived?.summary);
+  const rawMemory = asRecord(rawDerived?.memory);
+  const legacySummaryStatus = readEnum(rawSession.summaryStatus, ["pending", "complete"]);
+  const legacyMemoryCursor = readNumber(rawSession.lastMemorySyncCount);
+
+  const summaryText = readString(rawSummary?.text);
+  const summaryTitle = readString(rawSummary?.title);
+  const summaryStatus = readTaskStatus(
+    rawSummary?.status,
+    summaryText || legacySummaryStatus === "complete" ? "complete" : "idle",
+  );
+  const summaryCursor = clampCursor(
+    readNumber(rawSummary?.basedOnCursor),
+    summaryStatus === "complete" ? lastMirroredCount : 0,
+    lastMirroredCount,
+  );
+
+  const capturedCursor = clampCursor(
+    readNumber(rawMemory?.capturedCursor)
+      ?? readNumber(rawMemory?.appliedCursor)
+      ?? legacyMemoryCursor,
+    summaryStatus === "complete" ? lastMirroredCount : 0,
+    lastMirroredCount,
+  );
+  const memoryStatus = readTaskStatus(
+    rawMemory?.status ?? rawMemory?.extractStatus ?? rawMemory?.reconcileStatus,
+    capturedCursor >= lastMirroredCount && lastMirroredCount > 0 ? "complete" : "idle",
+  );
+  const candidates = readMemoryCandidates(rawMemory?.candidates);
 
-function migrateDerivedState(fallback: {
-  lastMirroredCount: number;
-  finalizedAt?: string;
-  summaryStatus?: "pending" | "complete";
-  lastMemorySyncCount?: number;
-}): SessionDerivedState {
-  const mirrorCursor = fallback.lastMirroredCount;
-  const finalized = Boolean(fallback.finalizedAt);
-  const summaryComplete = fallback.summaryStatus === "complete";
-  const appliedCursor = clampCursor(fallback.lastMemorySyncCount, mirrorCursor);
-  const digestCursor = finalized && summaryComplete ? mirrorCursor : 0;
   return {
-    digest: {
-      cursor: digestCursor,
-      status: digestCursor < mirrorCursor ? "pending" : "idle",
-      attempt: 0,
-    },
     summary: {
-      basedOnCursor: summaryComplete ? mirrorCursor : 0,
-      status: finalized ? (summaryComplete ? "complete" : "pending") : "idle",
+      basedOnCursor: summaryCursor,
+      status: finalizedAt && summaryStatus === "idle" && lastMirroredCount > 0 ? "error" : summaryStatus,
+      ...(summaryText ? { text: summaryText } : {}),
+      ...(summaryTitle ? { title: summaryTitle } : {}),
+      ...(readString(rawSummary?.lastError) ? { lastError: readString(rawSummary?.lastError) } : {}),
+      ...(readString(rawSummary?.updatedAt) ? { updatedAt: readString(rawSummary?.updatedAt) } : {}),
     },
     memory: {
-      extractCursor: appliedCursor,
-      appliedCursor,
-      extractStatus: appliedCursor < mirrorCursor ? "pending" : "idle",
-      reconcileStatus: "idle",
-      attempt: 0,
-      pendingCandidates: [],
+      capturedCursor,
+      status: memoryStatus,
+      ...(candidates ? { candidates } : {}),
+      ...(readString(rawMemory?.lastError) ? { lastError: readString(rawMemory?.lastError) } : {}),
+      ...(readString(rawMemory?.updatedAt) ? { updatedAt: readString(rawMemory?.updatedAt) } : {}),
     },
   };
 }
 
 function readString(value: unknown): string | undefined {
-  if (typeof value !== "string") {
-    return undefined;
-  }
+  if (typeof value !== "string") return undefined;
   const trimmed = value.trim();
   return trimmed ? trimmed : undefined;
 }
@@ -194,42 +149,55 @@ function readEnum<T extends string>(value: unknown, allowed: T[]): T | undefined
 }
 
 function readNumber(value: unknown): number | undefined {
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    return undefined;
-  }
+  if (typeof value !== "number" || !Number.isFinite(value)) return undefined;
   return Math.max(0, Math.floor(value));
 }
 
 function readTaskStatus(value: unknown, fallback: SessionTaskStatus): SessionTaskStatus {
   const status = readEnum(value, ["idle", "pending", "running", "complete", "error"]);
   if (!status) return fallback;
-  return status === "running" ? "pending" : status;
+  if (status === "pending" || status === "running") return "idle";
+  return status;
 }
 
-function sanitizeCandidate(value: unknown): MemoryCandidate | null {
+function readTitleSource(value: unknown): "placeholder" | "llm" | undefined {
+  const source = readEnum(value, ["placeholder", "digest", "llm"]);
+  if (!source) return undefined;
+  return source === "digest" ? "llm" : source;
+}
+
+function readMemoryCandidates(value: unknown): MemoryCandidate[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const out = value
+    .map((entry) => sanitizeMemoryCandidate(entry))
+    .filter((candidate): candidate is MemoryCandidate => candidate !== null);
+  return out;
+}
+
+function sanitizeMemoryCandidate(value: unknown): MemoryCandidate | null {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
   const record = value as Record<string, unknown>;
-  const detail = readString(record.detail);
   const candidateId = readString(record.candidateId);
-  if (!detail) return null;
+  const detail = readString(record.detail);
+  if (!candidateId || !detail) return null;
+  const title = readString(record.title);
+  const kind = readString(record.kind);
+  const topics = Array.isArray(record.topics)
+    ? record.topics.map((topic) => readString(topic)).filter((topic): topic is string => Boolean(topic))
+    : undefined;
+  const evidence = readString(record.evidence);
   return {
-    candidateId: candidateId ?? detail,
+    candidateId,
     detail,
-    ...(readString(record.title) ? { title: readString(record.title) } : {}),
-    ...(readString(record.kind) ? { kind: readString(record.kind) } : {}),
-    ...(Array.isArray(record.topics)
-      ? {
-          topics: record.topics
-            .map((topic) => readString(topic))
-            .filter((topic): topic is string => Boolean(topic)),
-        }
-      : {}),
-    ...(readString(record.evidence) ? { evidence: readString(record.evidence) } : {}),
+    ...(title ? { title } : {}),
+    ...(kind ? { kind } : {}),
+    ...(topics && topics.length > 0 ? { topics } : {}),
+    ...(evidence ? { evidence } : {}),
   };
 }
 
-function clampCursor(value: number | undefined, max: number): number {
-  if (typeof value !== "number" || !Number.isFinite(value)) return 0;
+function clampCursor(value: number | undefined, fallback: number, max: number): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) return Math.min(max, Math.max(0, fallback));
   return Math.min(max, Math.max(0, Math.floor(value)));
 }
 

package/src/types.ts

@@ -16,11 +16,8 @@ export type ClawMemPluginConfig = {
   agents: Record<string, ClawMemAgentConfig>;
   memoryRecallLimit: number;
   memoryAutoRecallLimit: number;
-  turnCommentDelayMs: number;
-  digestWaitTimeoutMs: number;
   summaryWaitTimeoutMs: number;
   memoryExtractWaitTimeoutMs: number;
-  memoryReconcileWaitTimeoutMs: number;
 };
 
 export type ClawMemResolvedRoute = {
@@ -35,7 +32,7 @@ export type ClawMemResolvedRoute = {
 export type BootstrapIdentityResponse = { token: string; repo_full_name: string };
 export type AgentRegistrationResponse = BootstrapIdentityResponse & { login: string };
 export type AnonymousSessionResponse = BootstrapIdentityResponse & { owner_login: string; repo_name: string };
-export type SessionTaskStatus = "idle" | "pending" | "running" | "complete" | "error";
+export type SessionTaskStatus = "idle" | "complete" | "error";
 export type MemoryCandidate = {
   candidateId: string;
   detail: string;
@@ -44,48 +41,34 @@ export type MemoryCandidate = {
   topics?: string[];
   evidence?: string;
 };
-export type SessionDigestState = {
-  cursor: number;
-  status: SessionTaskStatus;
-  attempt: number;
-  text?: string;
-  title?: string;
-  lastError?: string;
-  updatedAt?: string;
-};
 export type SessionSummaryState = {
   basedOnCursor: number;
   status: SessionTaskStatus;
   text?: string;
+  title?: string;
   lastError?: string;
   updatedAt?: string;
 };
 export type SessionMemoryState = {
-  extractCursor: number;
-  appliedCursor: number;
-  extractStatus: SessionTaskStatus;
-  reconcileStatus: SessionTaskStatus;
-  attempt: number;
-  pendingCandidates: MemoryCandidate[];
+  capturedCursor: number;
+  status: SessionTaskStatus;
+  candidates?: MemoryCandidate[];
   lastError?: string;
   updatedAt?: string;
 };
 export type SessionDerivedState = {
-  digest: SessionDigestState;
   summary: SessionSummaryState;
   memory: SessionMemoryState;
 };
 export type SessionMirrorState = {
   sessionId: string; sessionKey?: string; sessionFile?: string; agentId?: string;
-  issueNumber?: number; issueTitle?: string; titleSource?: "placeholder" | "digest" | "llm";
-  lastMirroredCount: number; turnCount: number; lastAssistantText?: string;
-  lastMemorySyncCount?: number;
-  summaryStatus?: "pending" | "complete";
-  finalizedAt?: string; lastSummaryHash?: string; lastTurnHash?: string;
+  issueNumber?: number; issueTitle?: string; titleSource?: "placeholder" | "llm";
+  lastMirroredCount: number; turnCount: number;
+  finalizedAt?: string; lastSummaryHash?: string;
   derived?: SessionDerivedState;
   createdAt?: string; updatedAt?: string;
 };
-export type PluginState = { version: 3; sessions: Record<string, SessionMirrorState>; migrations?: Record<string, string> };
+export type PluginState = { version: 4; sessions: Record<string, SessionMirrorState>; migrations?: Record<string, string> };
 export type NormalizedMessage = { role: string; text: string; toolName?: string; timestamp?: string; stopReason?: string };
 export type TranscriptSnapshot = { sessionId?: string; messages: NormalizedMessage[] };
 export type MemoryDraft = { title?: string; detail: string; kind?: string; topics?: string[] };

package/tsconfig.json

@@ -1,6 +1,7 @@
 {
   "extends": "../openclaw/tsconfig.json",
   "compilerOptions": {
+    "outDir": "./dist",
     "baseUrl": ".",
     "paths": {
       "openclaw/plugin-sdk": ["../openclaw/src/plugin-sdk/index.ts"],