fix: consolidate endpoint returns proper error message (#1008)

package.json

@@ -1,7 +1,7 @@
 {
-  "name": "@agentmemory/agentmemory",
-  "version": "0.9.27",
-  "description": "Persistent memory for AI coding agents, powered by iii-engine's three primitives",
+  "name": "ziiagentmemory",
+  "version": "0.2.0",
+  "description": "Persistent memory for AI coding agents — CJK-aware dedup, memory_update versioning, standalone MCP server",
   "type": "module",
   "main": "dist/index.mjs",
   "types": "dist/index.d.mts",
@@ -14,6 +14,7 @@
     "./package.json": "./package.json"
   },
   "bin": {
+    "ziiagentmemory": "dist/cli.mjs",
     "agentmemory": "dist/cli.mjs"
   },
   "scripts": {
@@ -53,11 +54,16 @@
     "README.md",
     "AGENTS.md"
   ],
-  "author": "Rohit Ghumare <ghumare64@gmail.com>",
+  "author": "Zeeshan Ahmad <ziishanahmad@gmail.com>",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "https://github.com/rohitg00/agentmemory"
+    "url": "https://github.com/ziishanahmad/ziiagentmemory"
+  },
+  "homepage": "https://github.com/ziishanahmad/ziiagentmemory",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.3.142",

src/functions/remember.ts

@@ -1,6 +1,7 @@
 import { TriggerAction, type ISdk } from "iii-sdk";
 import type { Memory } from "../types.js";
 import { KV, generateId, jaccardSimilarity } from "../state/schema.js";
+import { isNegationConflict } from "../state/memory-dedup.js";
 import { StateKV } from "../state/kv.js";
 import { withKeyedLock } from "../state/keyed-mutex.js";
 import { memoryToObservation } from "../state/memory-utils.js";
@@ -78,7 +79,7 @@ export function registerRememberFunction(sdk: ISdk, kv: StateKV): void {
             lowerContent,
             existing.content.toLowerCase(),
           );
-          if (similarity > 0.7) {
+          if (similarity > 0.7 && !isNegationConflict(lowerContent, existing.content.toLowerCase())) {
             supersededId = existing.id;
             supersededVersion = existing.version ?? 1;
             supersededMemory = existing;
@@ -167,6 +168,129 @@ export function registerRememberFunction(sdk: ISdk, kv: StateKV): void {
     },
   );
 
+  // ── mem::update ─────────────────────────────────────────────────────
+  // Updates an existing memory by ID: sets new content, increments version,
+  // and marks the old memory as superseded.  This fills the gap identified
+  // in #1018 where calling memory_save twice with the same concepts created
+  // two separate v1 memories instead of versioning.
+  sdk.registerFunction("mem::update",
+    async (data: {
+      memoryId: string;
+      content: string;
+      type?: string;
+      concepts?: string[];
+      files?: string[];
+      ttlDays?: number;
+      agentId?: string;
+    }) => {
+      if (!data.memoryId || typeof data.memoryId !== "string") {
+        return { success: false, error: "memoryId is required" };
+      }
+      if (
+        !data.content ||
+        typeof data.content !== "string" ||
+        !data.content.trim()
+      ) {
+        return { success: false, error: "content is required" };
+      }
+
+      return withKeyedLock("mem:update", async () => {
+        const existing = await kv.get<Memory>(KV.memories, data.memoryId);
+        if (!existing) {
+          return { success: false, error: "memory not found" };
+        }
+
+        const now = new Date().toISOString();
+        const newVersion = (existing.version ?? 1) + 1;
+        const validTypes = new Set([
+          "pattern",
+          "preference",
+          "architecture",
+          "bug",
+          "workflow",
+          "fact",
+        ]);
+        const memType = validTypes.has(data.type || "")
+          ? (data.type as Memory["type"])
+          : existing.type;
+
+        const callAgentId =
+          typeof data.agentId === "string" && data.agentId.trim().length > 0
+            ? data.agentId.trim().slice(0, 128)
+            : getAgentId();
+
+        const updated: Memory = {
+          id: existing.id,
+          createdAt: existing.createdAt,
+          updatedAt: now,
+          type: memType,
+          title: data.content.slice(0, 80),
+          content: data.content,
+          concepts: data.concepts ?? existing.concepts,
+          files: data.files ?? existing.files,
+          sessionIds: existing.sessionIds,
+          strength: existing.strength,
+          version: newVersion,
+          parentId: existing.parentId,
+          supersedes: [...(existing.supersedes ?? []), existing.id],
+          sourceObservationIds: existing.sourceObservationIds,
+          isLatest: true,
+          forgetAfter: existing.forgetAfter,
+          ...(existing.imageRef ? { imageRef: existing.imageRef } : {}),
+          ...(existing.imageData ? { imageData: existing.imageData } : {}),
+          ...(callAgentId ? { agentId: callAgentId } : {}),
+          ...(existing.project !== undefined && { project: existing.project }),
+        };
+
+        if (data.ttlDays && typeof data.ttlDays === "number" && data.ttlDays > 0) {
+          updated.forgetAfter = new Date(
+            Date.now() + data.ttlDays * 86400000,
+          ).toISOString();
+        }
+
+        // Mark the old version as no longer latest.
+        existing.isLatest = false;
+        existing.updatedAt = now;
+        await kv.set(KV.memories, existing.id, existing);
+
+        // Save the updated memory in-place (same ID, new version).
+        await kv.set(KV.memories, updated.id, updated);
+
+        // Re-index: remove old content, add new.
+        try {
+          getSearchIndex().remove(existing.id);
+          getSearchIndex().add(memoryToObservation(updated));
+        } catch (err) {
+          logger.warn("Failed to re-index updated memory in BM25", {
+            memId: updated.id,
+            error: err instanceof Error ? err.message : String(err),
+          });
+        }
+        await vectorIndexRemove(updated.id);
+        await vectorIndexAddGuarded(
+          updated.id,
+          updated.sessionIds?.[0] ?? "memory",
+          updated.title + " " + updated.content,
+          { kind: "memory", logId: updated.id },
+        );
+
+        await recordAudit(kv, "update", "mem::update", [updated.id], {
+          memoryId: updated.id,
+          oldVersion: existing.version ?? 1,
+          newVersion,
+          reason: "user-initiated update",
+        });
+
+        logger.info("Memory updated", {
+          memId: updated.id,
+          oldVersion: existing.version ?? 1,
+          newVersion,
+        });
+        return { success: true, memory: updated };
+      });
+    },
+  );
+
   sdk.registerFunction("mem::forget",
     async (data: {
       sessionId?: string;

src/functions/summarize.ts

@@ -260,7 +260,7 @@ export function registerSummarizeFunction(
         return { success: false, error: "no_observations" };
       }
 
-      if (provider.name === "noop") {
+      if (provider.name === "noop" || provider.name === "resilient(noop)") {
         logger.info("Summarize skipped — no LLM provider configured", {
           sessionId,
         });

src/index.ts

@@ -350,6 +350,16 @@ async function main() {
     bootLog(
       `Git snapshots: ${snapshotConfig.dir} (every ${snapshotConfig.interval}s)`,
     );
+    // #1006: actually schedule the periodic snapshot timer. Previously
+    // the interval was read and logged but never passed to setInterval,
+    // so snapshots only happened on manual trigger.
+    const snapshotIntervalMs = snapshotConfig.interval * 1000;
+    const snapshotTimer = setInterval(async () => {
+      try {
+        await sdk.trigger({ function_id: "mem::snapshot-create", payload: {} });
+      } catch {}
+    }, snapshotIntervalMs);
+    snapshotTimer.unref();
   }
 
   const bm25Index = getSearchIndex();

src/mcp/standalone.ts

@@ -15,6 +15,7 @@ import {
 
 const IMPLEMENTED_TOOLS = new Set([
   "memory_save",
+  "memory_update",
   "memory_recall",
   "memory_smart_search",
   "memory_sessions",
@@ -96,6 +97,7 @@ function textResponse(payload: unknown, pretty = false): {
 interface Validated {
   tool: string;
   content?: string;
+  memoryId?: string;
   type?: string;
   concepts?: string[];
   files?: string[];
@@ -124,6 +126,24 @@ function validate(toolName: string, args: Record<string, unknown>): Validated {
       v.files = normalizeList(args["files"]);
       return v;
     }
+    case "memory_update": {
+      const memoryId = args["memoryId"];
+      if (typeof memoryId !== "string" || !memoryId.trim()) {
+        throw new Error("memoryId is required");
+      }
+      const content = args["content"];
+      if (typeof content !== "string" || !content.trim()) {
+        throw new Error("content is required");
+      }
+      v.memoryId = memoryId;
+      v.content = content;
+      if (typeof args["type"] === "string" && args["type"].trim()) {
+        v.type = args["type"] as string;
+      }
+      v.concepts = normalizeList(args["concepts"]);
+      v.files = normalizeList(args["files"]);
+      return v;
+    }
     case "memory_recall":
     case "memory_smart_search": {
       const query = args["query"];
@@ -182,7 +202,21 @@ async function handleProxy(
           files: v.files,
         }),
       });
-      return textResponse(result);
+      return textResponse(result, true);
+    }
+    case "memory_update": {
+      const body: Record<string, unknown> = {
+        memoryId: v.memoryId,
+        content: v.content,
+      };
+      if (v.type) body["type"] = v.type;
+      if (v.concepts) body["concepts"] = v.concepts;
+      if (v.files) body["files"] = v.files;
+      const result = await handle.call("/agentmemory/memories/update", {
+        method: "PUT",
+        body: JSON.stringify(body),
+      });
+      return textResponse(result, true);
     }
     case "memory_recall": {
       const body: Record<string, unknown> = {
@@ -263,6 +297,45 @@ async function handleLocal(
       return textResponse({ saved: id });
     }
 
+    case "memory_update": {
+      const existing = await kvInstance.get<Record<string, unknown>>(
+        "mem:memories",
+        v.memoryId!,
+      );
+      if (!existing) {
+        return textResponse({ success: false, error: "memory not found" });
+      }
+      const oldVersion =
+        typeof existing["version"] === "number" ? existing["version"] : 1;
+      const newVersion = oldVersion + 1;
+      const isoNow = new Date().toISOString();
+      const updated = {
+        ...existing,
+        type: v.type ?? existing["type"],
+        title: (v.content || "").slice(0, 80),
+        content: v.content,
+        concepts: v.concepts ?? existing["concepts"],
+        files: v.files ?? existing["files"],
+        updatedAt: isoNow,
+        version: newVersion,
+        isLatest: true,
+        supersedes: [
+          ...(Array.isArray(existing["supersedes"])
+            ? (existing["supersedes"] as string[])
+            : []),
+          v.memoryId!,
+        ],
+      };
+      await kvInstance.set("mem:memories", v.memoryId!, updated);
+      kvInstance.persist();
+      return textResponse({
+        success: true,
+        memory: updated,
+        oldVersion,
+        newVersion,
+      });
+    }
+
     case "memory_recall":
     case "memory_smart_search": {
       const query = (v.query || "").toLowerCase();

src/mcp/tools-registry.ts

@@ -87,6 +87,40 @@ export const CORE_TOOLS: McpToolDef[] = [
       required: ["content"],
     },
   },
+  {
+    name: "memory_update",
+    description:
+      "Update an existing memory by ID with new content. Increments the version " +
+      "and supersedes the old content. Use this instead of calling memory_save twice " +
+      "when you want to revise a memory rather than create a duplicate.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        memoryId: {
+          type: "string",
+          description: "The ID of the memory to update (e.g. mem_xxx)",
+        },
+        content: {
+          type: "string",
+          description: "The new content for the memory",
+        },
+        type: {
+          type: "string",
+          description:
+            "New memory type (optional, keeps existing if omitted): pattern, preference, architecture, bug, workflow, or fact",
+        },
+        concepts: {
+          type: "string",
+          description: "Comma-separated key concepts (optional, keeps existing if omitted)",
+        },
+        files: {
+          type: "string",
+          description: "Comma-separated relevant file paths (optional, keeps existing if omitted)",
+        },
+      },
+      required: ["memoryId", "content"],
+    },
+  },
   {
     name: "memory_file_history",
     description: "Get past observations about specific files.",

src/state/memory-dedup.ts

@@ -0,0 +1,32 @@
+/**
+ * Negation guard for memory dedup.
+ *
+ * Prevents "do X" from superseding "do not X" (and vice versa) even when
+ * the two strings share enough tokens to exceed the Jaccard threshold.
+ *
+ * The guard is deliberately narrow and conservative:
+ * - Only triggers when one side has a negation marker and the other does not.
+ * - Supports English ("not", "never", "don't", "do not") and CJK
+ *   ("不要", "别", "無", "なし", "않") markers.
+ * - If BOTH sides have negation markers, they are treated as compatible
+ *   (both say "don't do X") and the guard does not fire.
+ */
+
+const EN_NEGATION = /\b(not|never|don't|do not|cannot|should not|must not|no)\b/i;
+const CJK_NEGATION = /不要|别|勿|無|无|不|なし|않|안|못/i;
+
+function hasNegation(text: string): boolean {
+  return EN_NEGATION.test(text) || CJK_NEGATION.test(text);
+}
+
+/**
+ * Returns true if the two texts appear to be in a negation conflict
+ * (one says do X, the other says do NOT do X) and should NOT be superseded.
+ */
+export function isNegationConflict(a: string, b: string): boolean {
+  const aNeg = hasNegation(a);
+  const bNeg = hasNegation(b);
+  // If both have negation or neither does, no conflict.
+  if (aNeg === bNeg) return false;
+  return true;
+}