@clawmem-ai/clawmem 0.1.13 → 0.1.15

package/README.md

@@ -138,7 +138,7 @@ Full config with all options:
           turnCommentDelayMs: 1000,
           summaryWaitTimeoutMs: 120000,
           memoryRecallLimit: 5,
-          memoryAutoRecallLimit: 5
+          memoryAutoRecallLimit: 3
         }
       }
     }
@@ -152,8 +152,9 @@ Full config with all options:
 
 - Conversation comments exclude tool calls, tool results, system messages, and heartbeat noise.
 - Summary failures do not block finalization; the `summary` field is written as `failed: ...`.
-- Memory search and auto-injection only return open `type:memory` issues. Closed memory issues are treated as stale.
-- `memory_recall` now prefers the backend `/api/v3/search/issues` endpoint scoped to the current repo plus `label:"type:memory"`, with a simple local lexical fallback when backend search is unavailable or returns no matches.
+- Memory search and auto-recall only return open `type:memory` issues. Closed memory issues are treated as stale.
+- ClawMem automatically injects a small set of relevant memories before each turn using the agent's default repo and the backend recall API. Auto-recall is best-effort and quietly skips injection when backend recall is unavailable.
+- `memory_recall` uses the backend `/api/v3/search/issues` endpoint scoped to the current repo plus `label:"type:memory"`. When backend recall is unavailable, use `memory_list` or `memory_get` to inspect memories explicitly.
 - Durable memories are extracted best-effort during later request-scoped maintenance, not by background subagent work after a request has already ended.
 - The plugin exposes `memory_repos`, `memory_repo_create`, `memory_list`, `memory_get`, `memory_labels`, `memory_recall`, `memory_store`, `memory_update`, and `memory_forget` for mid-session use.
 - Route resolution is now: agent identity supplies credentials, `defaultRepo` is the fallback memory space, and explicit tool calls may override repo per operation.
@@ -162,4 +163,4 @@ Full config with all options:
 - `memory_update` updates one existing memory issue in place; use it for evolving canonical facts or active tasks instead of creating a duplicate node.
 - Conversation lifecycle is stored in native issue state (`open` while live, `closed` after finalize); memory lifecycle uses native issue state too (`open` active, `closed` stale).
 - Memory extraction now prefers one atomic fact per memory item instead of bundling whole sessions into a single node.
-- Memory issue bodies store the durable detail plus flat metadata such as `memory_hash` and logical `date`; labels are reserved for schema and routing.
+- Memory issue bodies store the durable detail in a YAML `detail` field plus flat metadata such as `memory_hash` and logical `date`; this matches the current Console parser in `agent-git-service/web`.

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "clawmem",
   "name": "ClawMem",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "Mirror OpenClaw sessions into GitHub-compatible issues and comments.",
   "kind": "memory",
   "skills": [
@@ -127,7 +127,7 @@
     },
     "memoryAutoRecallLimit": {
       "label": "Auto Recall Limit",
-      "help": "Maximum number of active memories injected into context before an agent starts."
+      "help": "Maximum number of active memories automatically injected before each turn."
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawmem-ai/clawmem",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "Mirror OpenClaw sessions into GitHub-compatible issues and comments.",
   "type": "module",
   "license": "MIT",

package/skills/clawmem/SKILL.md

@@ -25,20 +25,22 @@ Memory hygiene matters: lock important insights deliberately, update canonical f
 The ClawMem plugin automatically handles:
 - Per-agent provisioning of credentials plus a default memory repo
 - Session mirroring into `type:conversation` issues
+- Best-effort automatic memory recall before each turn, scoped to the current agent's `defaultRepo`
 - Best-effort durable memory extraction during later request-scoped maintenance
-- Automatic recall of relevant active memories at session start
 - Mid-session memory tools: `memory_repos`, `memory_repo_create`, `memory_list`, `memory_get`, `memory_labels`, `memory_recall`, `memory_store`, `memory_update`, and `memory_forget`
 
-Automatic recall is only a bootstrap. You still need to retrieve before answering when memory may matter, and save after learning something durable.
-
 ## Mandatory turn loop
 
 On every user turn, run this loop:
 
 1. Before answering, ask: could ClawMem improve this answer?
    - Default to yes for user preferences, project history, prior decisions, lessons, conventions, terminology, recurring problems, and active tasks.
-   - Before explicit memory work, choose the right repo. If unclear, inspect `memory_repos` and fall back to the agent's `defaultRepo`.
-   - Start with `memory_recall`.
+   - Auto-recall may already inject useful context from the current agent's `defaultRepo`, but it is only a hint. Do not treat missing auto-recall context as proof that no relevant memory exists.
+   - If the injected context already answers the question, you do not need to immediately call `memory_recall` again.
+   - Auto-recall does not currently fan out across every accessible repo. Shared organization memory, team memory, and project memory outside the current `defaultRepo` will not be recalled automatically.
+   - Before explicit memory work, choose the right repo. If unclear, inspect `memory_repos` and fall back to the agent's `defaultRepo`. If the likely memory lives outside the default repo, use explicit repo selection instead of relying on auto-recall.
+   - Use `memory_recall` when injected context is missing, weak, cross-repo, high-stakes, or when you need an explicit retrieval trace.
+   - Write `memory_recall.query` as a short natural-language intent. Do not paste long code blocks, full logs, tool chatter, or system prompt text unless the exact wording is necessary.
    - When the question spans more than one angle, run more than one recall query across keywords, topics, synonyms, and likely project phrasing.
    - If `memory_recall` is weak or empty and the answer depends on whether a memory exists, cross-check with `memory_list`.
    - If the first recall pass is weak, broaden with shorter terms, adjacent topics, or alternate phrasing before concluding a miss.
@@ -50,14 +52,16 @@ On every user turn, run this loop:
    - Use `memory_update` when the same canonical fact or ongoing task should keep evolving as one node.
    - When updating an existing memory, preserve that node's current language unless the user explicitly asks for a rewrite.
    - Use `memory_store` when this is a genuinely new memory.
+   - When using `memory_store`, pass both `title` and `detail` when you can. Keep the title concise and human-readable, and keep `detail` as the full durable fact.
+   - When using `memory_update`, pass `title` as well if the existing title is too short, outdated, or less precise than the current canonical fact.
    - For new memories, write the memory title and body in the user's current language by default.
    - Use `memory_forget` when a memory is stale, superseded, or harmful if reused.
 3. Keep the user posted.
-   - If a retrieved memory materially shaped the answer, including automatic session-start recall, briefly surface that fact in the user's current language.
+   - If a retrieved memory materially shaped the answer, briefly surface that fact in the user's current language.
    - Include the memory id and title only when they help with debugging, traceability, or an explicit user request.
    - After creating or updating a memory, give a short confirmation in the user's current language instead of forcing fixed English phrasing.
 
-Bias toward retrieving and saving. A missed search or missed memory is worse than an extra search.
+Bias toward saving, and use explicit retrieval whenever auto-recall is absent, weak, cross-repo, or too ambiguous to trust on its own.
 
 ## Retrieval and storage rules
 
@@ -67,7 +71,10 @@ Bias toward retrieving and saving. A missed search or missed memory is worse tha
 - Private personal memory usually belongs in the agent's `defaultRepo`.
 - Project memory belongs in the relevant project repo.
 - Shared or team knowledge belongs in the shared repo for that group.
+- Shared or team knowledge in another repo is not part of default auto-recall today. To use it, select that repo explicitly with `memory_recall`, `memory_list`, or `memory_get`.
 - Memory titles and bodies default to the user's current language for new memories.
+- Prefer a short standalone title plus a fuller `detail` body instead of stuffing the whole memory into the title.
+- If you omit `title`, the plugin may derive it from `detail`, but providing an explicit title is preferred for readability in the Console.
 - When updating an existing memory, keep that node in its current language unless the user explicitly asks to rewrite it.
 - Keep schema labels and machine-oriented fields stable. Do not translate `type:*`, `kind:*`, `topic:*`, or other structural identifiers.
 - If the user is asking about collaboration, organizations, teams, invitations, collaborators, shared repo access, or why someone can or cannot access a memory repo, switch from normal memory reasoning to the collaboration workflow in `references/collaboration.md`.

package/skills/clawmem/references/manual-ops.md

@@ -76,6 +76,7 @@ Do not export `GH_HOST` or `GH_ENTERPRISE_TOKEN` globally for unrelated github.c
 Use the tool path first. If raw issue control is required:
 
 - For new memories, write the issue title and body in the user's current language.
+- Prefer a concise standalone title and keep the full durable fact in the body.
 - When manually updating an existing memory, preserve that memory's current language unless the user explicitly asks for a rewrite.
 - Keep labels and schema markers such as `type:*`, `kind:*`, and `topic:*` in their fixed machine-readable form.
 

package/skills/clawmem/references/schema.md

@@ -61,6 +61,8 @@ If you create a curated memory manually, include:
 ## Storage language
 
 - For new memory nodes, write the human-readable title and body in the user's current language by default.
+- When using plugin tools, prefer passing an explicit short `title` plus a fuller `detail` body.
+- Do not treat the title as the only durable content. The body detail should still contain the full reusable fact.
 - When updating an existing memory node, preserve that node's current language unless the user explicitly asks for a rewrite.
 - Do not translate schema or routing markers such as `type:*`, `kind:*`, `topic:*`, or other machine-oriented field names.
 

package/src/config.test.ts

@@ -27,7 +27,7 @@ function baseConfig(): ClawMemPluginConfig {
       },
     },
     memoryRecallLimit: 5,
-    memoryAutoRecallLimit: 5,
+    memoryAutoRecallLimit: 3,
     turnCommentDelayMs: 1000,
     summaryWaitTimeoutMs: 120000,
   };

package/src/config.ts

@@ -46,7 +46,7 @@ export function resolvePluginConfig(api: OpenClawPluginApi): ClawMemPluginConfig
     authScheme: raw.authScheme === "bearer" ? "bearer" : "token",
     agents,
     memoryRecallLimit: clamp(num(raw.memoryRecallLimit, 5), 1, 20),
-    memoryAutoRecallLimit: clamp(num(raw.memoryAutoRecallLimit, num(raw.memoryRecallLimit, 5)), 1, 20),
+    memoryAutoRecallLimit: clamp(num(raw.memoryAutoRecallLimit, 3), 1, 20),
     turnCommentDelayMs: num(raw.turnCommentDelayMs, 1000),
     summaryWaitTimeoutMs: clamp(num(raw.summaryWaitTimeoutMs, 120000), 1000, 600000),
   };

package/src/memory.test.ts

@@ -44,46 +44,53 @@ function assert(condition: unknown, message: string): void {
 function testConfig(): never {
   return {
     memoryRecallLimit: 5,
-    memoryAutoRecallLimit: 5,
+    memoryAutoRecallLimit: 3,
     turnCommentDelayMs: 1000,
     summaryWaitTimeoutMs: 120000,
   } as never;
 }
 
-async function testSearchRanking(): Promise<void> {
-  const issues = [
-    issueFromMemory(memory({
-      issueNumber: 1,
-      title: "Memory: Redis rate limit tuning",
-      detail: "Distributed Redis rate limiting must use Lua scripts to stay atomic.",
-      kind: "lesson",
-      topics: ["redis", "rate-limiting"],
-    })),
-    issueFromMemory(memory({
-      issueNumber: 2,
-      title: "Memory: Generic backend notes",
-      detail: "We use Redis in several services, but this one is not about rate limiting.",
-      topics: ["backend"],
-    })),
-  ];
+async function testBackendSearchBuildsSingleCleanedQuery(): Promise<void> {
+  const queries: string[] = [];
   const client = {
-    listIssues: async () => issues,
+    repo: () => "owner/main-memory",
+    searchIssues: async (query: string) => {
+      queries.push(query);
+      return [] as IssueRecord[];
+    },
   };
   const store = new MemoryStore(client as never, {} as never, testConfig());
-  const found = await store.search("redis rate limiting", 5);
-  assert(found.length === 2, "expected both memories to match");
-  assert(found[0]?.issueNumber === 1, "expected the more specific Redis rate limiting memory to rank first");
+  await store.search([
+    "<clawmem-context>",
+    "- [11] Previous memory that should be stripped",
+    "</clawmem-context>",
+    "Conversation info (untrusted metadata):",
+    "```json",
+    '{"channel":"slack"}',
+    "```",
+    "",
+    "[message_id: abc-123]",
+    "",
+    "[Slack 2026-04-03 09:30]: Please help debug the Redis rate limiting path.",
+    "See https://example.com/debug for more context.",
+    "throw new TimeoutError('lua script timeout')",
+    "[System: auto-translated]",
+  ].join("\n"), 5);
+
+  assert(queries.length === 1, "expected a single backend search query");
+  assert(queries[0]?.includes("repo:owner/main-memory"), "expected the backend query to stay scoped to the repo");
+  assert(queries[0]?.includes('label:"type:memory"'), "expected the backend query to filter memory issues");
+  assert((queries[0] ?? "").length <= 1610, "expected the backend search query to stay within the configured cap plus qualifiers");
+  assert(queries[0]?.toLowerCase().includes("redis"), "expected the backend query to retain key terms");
+  assert(!queries[0]?.includes("<clawmem-context>"), "expected injected clawmem context to be stripped");
+  assert(!queries[0]?.includes("https://example.com/debug"), "expected URLs to be stripped from backend recall");
+  assert(!queries[0]?.includes("Conversation info (untrusted metadata):"), "expected inbound metadata blocks to be stripped");
+  assert(!queries[0]?.includes("[message_id:"), "expected message id hints to be stripped");
+  assert(!queries[0]?.includes("[Slack 2026-04-03 09:30]"), "expected envelope prefixes to be stripped");
+  assert(!queries[0]?.includes("[System: auto-translated]"), "expected trailing system hints to be stripped");
 }
 
 async function testBackendSearchPreferredForRecall(): Promise<void> {
-  const listed = [
-    issueFromMemory(memory({
-      issueNumber: 1,
-      title: "Memory: lexical decoy",
-      detail: "redis rate limiting checklist",
-      kind: "lesson",
-    })),
-  ];
   const searched = [
     issueFromMemory(memory({
       issueNumber: 2,
@@ -96,14 +103,13 @@ async function testBackendSearchPreferredForRecall(): Promise<void> {
   const queries: string[] = [];
   const client = {
     repo: () => "owner/main-memory",
-    listIssues: async () => listed,
     searchIssues: async (query: string) => {
       queries.push(query);
       return searched;
     },
   };
   const store = new MemoryStore(client as never, {} as never, testConfig());
-  const found = await store.search("redis rate limiting", 5);
+  const found = await store.search("redis rate limiting", 1);
 
   assert(queries.length === 1, "expected backend search to be called once");
   assert(queries[0]?.includes('repo:owner/main-memory'), "expected backend query to scope to the current repo");
@@ -111,7 +117,7 @@ async function testBackendSearchPreferredForRecall(): Promise<void> {
   assert(found.length === 1 && found[0]?.issueNumber === 2, "expected backend search results to be preferred");
 }
 
-async function testBackendSearchFallsBackToLocalLexical(): Promise<void> {
+async function testBackendSearchReturnsEmptyWithoutLexicalFallback(): Promise<void> {
   const issues = [
     issueFromMemory(memory({
       issueNumber: 3,
@@ -124,12 +130,28 @@ async function testBackendSearchFallsBackToLocalLexical(): Promise<void> {
   const client = {
     repo: () => "owner/main-memory",
     listIssues: async () => issues,
-    searchIssues: async () => { throw new Error("search unavailable"); },
+    searchIssues: async () => [] as IssueRecord[],
   };
-  const store = new MemoryStore(client as never, { logger: { warn: () => {} } } as never, testConfig());
+  const store = new MemoryStore(client as never, {} as never, testConfig());
   const found = await store.search("redis rate limiting", 5);
 
-  assert(found.length === 1 && found[0]?.issueNumber === 3, "expected lexical fallback when backend search fails");
+  assert(found.length === 0, "expected backend-only recall to return no results when the backend finds nothing");
+}
+
+async function testBackendSearchPropagatesErrors(): Promise<void> {
+  const client = {
+    repo: () => "owner/main-memory",
+    searchIssues: async () => { throw new Error("search unavailable"); },
+  };
+  const store = new MemoryStore(client as never, {} as never, testConfig());
+  let message = "";
+  try {
+    await store.search("redis rate limiting", 5);
+  } catch (error) {
+    message = String(error);
+  }
+
+  assert(message.includes("search unavailable"), "expected backend failures to propagate instead of falling back locally");
 }
 
 function testCjkScoring(): void {
@@ -177,12 +199,36 @@ async function testStructuredStoreAndSchema(): Promise<void> {
   assert(created[0]?.labels.includes("topic:rate-limit"), "expected created labels to include normalized topic");
   assert(!created[0]?.labels.some((label) => label.startsWith("session:")), "expected manual memory_store writes to omit synthetic session labels");
   assert(!created[0]?.labels.some((label) => label.startsWith("date:")), "expected new memory labels to omit date labels");
+  assert(created[0]?.body.includes("memory_hash:"), "expected new memory body to retain metadata fields");
+  assert(created[0]?.body.includes("detail: Redis Lua scripts are required for atomic rate limiting."), "expected new memory body to store detail in YAML");
   assert(created[0]?.body.includes(`date: ${result.memory.date}`), "expected new memory body to retain logical date metadata");
   assert(ensured[0]?.includes("kind:lesson"), "expected ensureLabels to include kind label");
   assert(schema.kinds.includes("lesson"), "expected schema to expose existing kind labels");
   assert(schema.topics.includes("redis"), "expected schema to expose existing topic labels");
 }
 
+async function testStoreKeepsFullAutoTitleAndSupportsExplicitTitle(): Promise<void> {
+  const created: Array<{ title: string; body: string; labels: string[] }> = [];
+  const client = {
+    listIssues: async () => [] as IssueRecord[],
+    listLabels: async () => [] as LabelRecord[],
+    ensureLabels: async () => {},
+    createIssue: async (payload: { title: string; body: string; labels: string[] }) => {
+      created.push(payload);
+      return { number: created.length + 100, title: payload.title };
+    },
+  };
+  const store = new MemoryStore(client as never, {} as never, testConfig());
+  const longDetail = "Tech Decision #001: Frontend = React Native, Backend = FastAPI, Database = PostgreSQL, and analytics events must stay append-only for auditability.";
+  const auto = await store.store({ detail: longDetail });
+  const explicit = await store.store({ title: "Architecture Decision #001", detail: "Use React Native + FastAPI for the first mobile stack." });
+
+  assert(auto.memory.title === `Memory: ${longDetail}`, "expected auto-generated memory title to keep the full detail without truncation");
+  assert(explicit.memory.title === "Memory: Architecture Decision #001", "expected explicit memory title to be preserved");
+  assert(created[0]?.title === `Memory: ${longDetail}`, "expected created issue title to keep the full auto title");
+  assert(created[1]?.title === "Memory: Architecture Decision #001", "expected created issue title to use the explicit title");
+}
+
 async function testGetAndListMemories(): Promise<void> {
   const issues = [
     issueFromMemory(memory({
@@ -241,6 +287,7 @@ async function testLegacyMemoriesWithoutSessionOrDate(): Promise<void> {
     },
   ];
   const client = {
+    repo: () => "owner/main-memory",
     listIssues: async (params?: { labels?: string[]; state?: "open" | "closed" | "all" }) => {
       const labels = params?.labels ?? [];
       const state = params?.state ?? "open";
@@ -251,6 +298,7 @@ async function testLegacyMemoriesWithoutSessionOrDate(): Promise<void> {
         return (issue.state ?? "open") === state;
       });
     },
+    searchIssues: async () => issues,
   };
   const store = new MemoryStore(client as never, {} as never, testConfig());
   const exact = await store.get("4");
@@ -312,10 +360,52 @@ async function testUpdateMemoryInPlace(): Promise<void> {
   assert(JSON.stringify(updated?.topics) === JSON.stringify(["preferences", "sports"]), "expected topics to be replaced");
   assert(updatedIssues.length === 1, "expected a single issue update");
   assert(updatedIssues[0]?.title !== "Memory: xiangz preferences", "expected title to refresh from updated detail");
+  assert(updatedIssues[0]?.body?.includes("memory_hash:"), "expected updated body to retain metadata");
+  assert(updatedIssues[0]?.body?.includes("detail:"), "expected updated body to store a detail field in YAML");
+  assert(updatedIssues[0]?.body?.includes("recently follows tennis"), "expected updated body to contain the updated detail text");
   assert(ensured[0]?.includes("topic:sports"), "expected new topic label to be ensured");
   assert(syncedLabels[0]?.labels.includes("kind:core-fact"), "expected existing kind label to be preserved");
 }
 
+async function testUpdateSupportsExplicitRetitle(): Promise<void> {
+  const issues: IssueRecord[] = [
+    issueFromMemory(memory({
+      issueNumber: 20,
+      title: "Memory: old short title",
+      detail: "We use append-only audit events for billing changes.",
+      kind: "convention",
+    })),
+  ];
+  const updatedIssues: Array<{ number: number; title?: string; body?: string }> = [];
+  const client = {
+    listIssues: async (params?: { labels?: string[]; state?: "open" | "closed" | "all" }) => {
+      const labels = params?.labels ?? [];
+      const state = params?.state ?? "open";
+      return issues.filter((issue) => {
+        const issueLabels = issue.labels ?? [];
+        if (!labels.every((label) => issueLabels.includes(label))) return false;
+        if (state === "all") return true;
+        return (issue.state ?? "open") === state;
+      });
+    },
+    ensureLabels: async () => {},
+    updateIssue: async (number: number, patch: { title?: string; body?: string }) => {
+      updatedIssues.push({ number, ...patch });
+      const issue = issues.find((entry) => entry.number === number);
+      if (!issue) throw new Error("issue missing");
+      if (patch.title) issue.title = patch.title;
+      if (patch.body) issue.body = patch.body;
+      return issue;
+    },
+    syncManagedLabels: async () => {},
+  };
+  const store = new MemoryStore(client as never, {} as never, testConfig());
+  const updated = await store.update("20", { title: "Billing Audit Convention" });
+
+  assert(updated?.title === "Memory: Billing Audit Convention", "expected memory_update to support explicit retitle");
+  assert(updatedIssues[0]?.title === "Memory: Billing Audit Convention", "expected issue title patch to use the explicit retitle");
+}
+
 async function testForgetClosesMemoryIssue(): Promise<void> {
   const issues: IssueRecord[] = [
     issueFromMemory(memory({
@@ -362,14 +452,17 @@ async function testForgetClosesMemoryIssue(): Promise<void> {
 }
 
 async function main(): Promise<void> {
-  await testSearchRanking();
+  await testBackendSearchBuildsSingleCleanedQuery();
   await testBackendSearchPreferredForRecall();
-  await testBackendSearchFallsBackToLocalLexical();
+  await testBackendSearchReturnsEmptyWithoutLexicalFallback();
+  await testBackendSearchPropagatesErrors();
   testCjkScoring();
   await testStructuredStoreAndSchema();
+  await testStoreKeepsFullAutoTitleAndSupportsExplicitTitle();
   await testGetAndListMemories();
   await testLegacyMemoriesWithoutSessionOrDate();
   await testUpdateMemoryInPlace();
+  await testUpdateSupportsExplicitRetitle();
   await testForgetClosesMemoryIssue();
   console.log("memory tests passed");
 }