@clawmem-ai/clawmem 0.1.15 → 0.1.17

package/README.md

@@ -4,8 +4,8 @@
 
 **What it does:**
 - Creates one `type:conversation` issue per session, mirrors the full transcript as comments.
-- During request-scoped hooks: best-effort extracts durable memories and stores each as a `type:memory` issue.
 - On session start: searches active memories by relevance and injects them into context.
+- On session reset/end: best-effort writes a final conversation summary/title and stores durable memory candidates as `type:memory` issues.
 - Lets agents inspect memory indexes and schema, fetch exact memories, update canonical facts in place, and write structured memories with `kind:*` and `topic:*` labels through plugin tools.
 
 ---
@@ -135,8 +135,8 @@ Full config with all options:
               token: "<token>"
             }
           },
-          turnCommentDelayMs: 1000,
           summaryWaitTimeoutMs: 120000,
+          memoryExtractWaitTimeoutMs: 45000,
           memoryRecallLimit: 5,
           memoryAutoRecallLimit: 3
         }
@@ -151,11 +151,13 @@ Full config with all options:
 ## Notes
 
 - 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: ...`.
+- Each `agent_end` mirrors conversation comments only; no background subagent-derived memory work runs after turns.
+- Finalization performs one request-scoped summarize-and-capture pass: generate the final issue summary/title plus durable memory candidates, then store exact-deduplicated memories.
+- Summary or memory-capture failures do not block finalization; the conversation issue still closes, and the mirrored transcript remains the durable source of truth for manual follow-up.
 - 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.
+- Automatic durable capture happens when the session resets or ends. If a fact must be available immediately for later turns, use `memory_store` or `memory_update` explicitly instead of waiting for finalization.
 - 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.
 - `memory_store` accepts optional schema hints such as kind and topics; the plugin normalizes them into managed `kind:*` and `topic:*` labels.

package/openclaw.plugin.json

@@ -1,8 +1,8 @@
 {
   "id": "clawmem",
   "name": "ClawMem",
-  "version": "0.1.15",
-  "description": "Mirror OpenClaw sessions into GitHub-compatible issues and comments.",
+  "version": "0.1.17",
+  "description": "Repo-backed long-term memory plugin for OpenClaw with auto recall, durable memory capture, and conversation mirroring.",
   "kind": "memory",
   "skills": [
     "./skills"
@@ -62,12 +62,12 @@
           }
         }
       },
-      "turnCommentDelayMs": {
+      "summaryWaitTimeoutMs": {
         "type": "integer",
-        "minimum": 0,
-        "maximum": 60000
+        "minimum": 1000,
+        "maximum": 600000
       },
-      "summaryWaitTimeoutMs": {
+      "memoryExtractWaitTimeoutMs": {
         "type": "integer",
         "minimum": 1000,
         "maximum": 600000
@@ -113,13 +113,13 @@
       "label": "Agent Routes",
       "help": "Per-agent ClawMem identities keyed by agent id. Each identity has credentials plus an optional defaultRepo."
     },
-    "turnCommentDelayMs": {
-      "label": "Turn Sync Delay (ms)",
-      "help": "Small delay so transcript writes settle before a turn comment is mirrored."
-    },
     "summaryWaitTimeoutMs": {
       "label": "Summary Wait Timeout (ms)",
-      "help": "How long clawmem waits for the OpenClaw subagent summarizer before writing a failed summary."
+      "help": "How long clawmem waits for the final conversation summary subagent during session finalization."
+    },
+    "memoryExtractWaitTimeoutMs": {
+      "label": "Finalize Memory Timeout (ms)",
+      "help": "How long clawmem waits while extracting durable memory candidates during session finalization."
     },
     "memoryRecallLimit": {
       "label": "Memory Recall Limit",

package/package.json

@@ -1,9 +1,19 @@
 {
   "name": "@clawmem-ai/clawmem",
-  "version": "0.1.15",
-  "description": "Mirror OpenClaw sessions into GitHub-compatible issues and comments.",
+  "version": "0.1.17",
+  "description": "Repo-backed long-term memory plugin for OpenClaw with auto recall, durable memory capture, and conversation mirroring.",
   "type": "module",
   "license": "MIT",
+  "keywords": [
+    "openclaw",
+    "clawmem",
+    "memory",
+    "long-term-memory",
+    "auto-recall",
+    "conversation-memory",
+    "github-compatible",
+    "plugin"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/clawmem-ai/clawmem-openclaw-plugin.git"

package/skills/clawmem/SKILL.md

@@ -26,7 +26,7 @@ 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
+- A best-effort final issue summary/title plus durable memory capture when the session resets or ends normally
 - Mid-session memory tools: `memory_repos`, `memory_repo_create`, `memory_list`, `memory_get`, `memory_labels`, `memory_recall`, `memory_store`, `memory_update`, and `memory_forget`
 
 ## Mandatory turn loop
@@ -48,12 +48,14 @@ On every user turn, run this loop:
    - Never treat a `memory_recall` miss by itself as proof that no relevant memory exists.
 2. After answering, ask: did this turn create durable knowledge?
    - Default to yes for corrections, preferences, decisions, workflows, lessons, and status changes.
+   - Automatic capture happens at session finalization and is best-effort. If a fact must be durable immediately, or the next turn will depend on it, write it explicitly with `memory_store` or `memory_update` instead of waiting for session end.
    - Prefer one durable fact per memory. If a turn contains several independent facts, save them separately instead of bundling them into one summary memory.
    - 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.
+   - Keep one durable fact per memory. Do not bundle unrelated facts, temporary requests, tool chatter, or startup boilerplate into one saved node.
    - 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.
@@ -61,12 +63,12 @@ On every user turn, run this loop:
    - 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 saving, and use explicit retrieval whenever auto-recall is absent, weak, cross-repo, or too ambiguous to trust on its own.
+Bias toward saving, and use explicit retrieval whenever auto-recall is absent, weak, cross-repo, or too ambiguous to trust on its own. Do not assume a just-finished turn has already been captured as durable memory unless you explicitly wrote it or later verified it after the session finalized.
 
 ## Retrieval and storage rules
 
 - Before inventing a new `kind` or `topic`, call `memory_labels` and reuse the existing schema when possible.
-- If the current schema does not fit and a new label would improve future retrieval or reuse, extend the schema intentionally within `kind:*` and `topic:*`.
+- If no current label fits, create one new stable machine-readable label within `kind:*` or `topic:*`. Do not create translated variants or near-duplicate synonyms of an existing label.
 - Reuse stable labels over one-off labels.
 - Private personal memory usually belongs in the agent's `defaultRepo`.
 - Project memory belongs in the relevant project repo.

package/skills/clawmem/references/collaboration.md

@@ -24,8 +24,12 @@ Use this reference when the user asks to:
 - invite someone into an organization
 - inspect, accept, or decline an invitation sent to the current user
 - create or manage a team
+- inspect or remove organization members or membership state
+- revoke a pending organization invitation from the org side
 - add or remove a repository collaborator
 - grant a team access to a repo
+- rename or delete a team, or inspect team members
+- move an existing memory repo into an organization
 - inspect outside collaborators
 - create a shared team memory repo or org-owned memory space
 - debug why a user can or cannot access a repo
@@ -45,7 +49,11 @@ Do not use this workflow for ordinary memory recall or save actions unless the u
 Tool-first rule:
 - Read-only inspection:
   - `collaboration_orgs`
+  - `collaboration_org_members`
+  - `collaboration_org_membership`
   - `collaboration_teams`
+  - `collaboration_team`
+  - `collaboration_team_members`
   - `collaboration_team_repos`
   - `collaboration_repo_collaborators`
   - `collaboration_repo_invitations`
@@ -56,16 +64,22 @@ Tool-first rule:
   - `collaboration_repo_access_inspect`
 - Mutations:
   - `collaboration_org_create`
+  - `collaboration_org_member_remove`
+  - `collaboration_org_membership_remove`
   - `collaboration_team_create`
+  - `collaboration_team_update`
+  - `collaboration_team_delete`
   - `collaboration_team_membership_set`
   - `collaboration_team_membership_remove`
   - `collaboration_team_repo_set`
   - `collaboration_team_repo_remove`
+  - `collaboration_repo_transfer`
   - `collaboration_repo_collaborator_set`
   - `collaboration_repo_collaborator_remove`
   - `collaboration_user_repo_invitation_accept`
   - `collaboration_user_repo_invitation_decline`
   - `collaboration_org_invitation_create`
+  - `collaboration_org_invitation_revoke`
   - `collaboration_user_org_invitation_accept`
   - `collaboration_user_org_invitation_decline`
 
@@ -103,6 +117,7 @@ Reason with these rules before every collaboration action:
 - Accepting a repository invitation is what turns a pending share into visible repo access for the invitee.
 - Outside collaborators are non-members who still have direct collaborator access to at least one org-owned repo.
 - Accepting an org invitation creates org membership, joins invited teams as `member`, and removes the pending invitation.
+- Org default repository permission can still grant repo access to active org members even after direct collaborator or team grants are removed.
 - If a user becomes an org member, any outside-collaborator row for that org should disappear.
 - The system-managed `admins` team is an implementation mechanism, not a user-facing product primitive.
 
@@ -114,8 +129,10 @@ Use this decision map:
 |---|---|
 | Give one user access to one repo without org membership | Direct collaborator |
 | Bring one user into the org | Org invitation |
+| Inspect whether a user already has org membership or only a pending org invite | Org membership inspection |
 | Grant a group access to selected repos | Team + team-repo grant |
 | Create a shared team memory space | Org-owned repo + team-repo grant |
+| Move an existing memory repo under org governance | Repo transfer into org |
 | Create another memory space under the current agent identity | `memory_repo_create` |
 | Inspect non-members who still have repo access | Outside collaborator listing |
 
@@ -152,6 +169,24 @@ Translate user intent like this:
 - `Bring Alice into the org and platform team`
   - inspect teams first with `collaboration_teams`
   - then use `collaboration_org_invitation_create`
+- `Show me who is in this org`
+  - use `collaboration_org_members`
+  - if you need one person's exact state, use `collaboration_org_membership`
+- `Remove Alice from the org`
+  - inspect `collaboration_org_membership` first
+  - if Alice is an active org member, use `collaboration_org_member_remove`
+  - if you want one command that also handles pending invites, use `collaboration_org_membership_remove`
+- `Revoke the pending org invite for Alice`
+  - inspect `collaboration_org_invitations` to get the invitation id
+  - then use `collaboration_org_invitation_revoke`
+- `Rename or delete this team`
+  - inspect the team with `collaboration_team`
+  - use `collaboration_team_update` or `collaboration_team_delete`
+- `Who is in team platform?`
+  - use `collaboration_team_members`
+- `Move this repo into org acme so team access can govern it`
+  - ensure the target org already exists and the actor has org admin rights
+  - then use `collaboration_repo_transfer`
 - `Someone shared a memory repo with me; can you see it and accept it?`
   - start with `collaboration_user_repo_invitations`
   - do not treat a `memory_repos` miss as proof that no share exists
@@ -161,9 +196,12 @@ Translate user intent like this:
   - if needed, have the repo owner inspect `collaboration_repo_invitations`
 - `Why can Bob still see this repo?`
   - start with `collaboration_repo_access_inspect`
+  - if you know the username, pass it so the tool can check org membership and org-base access explicitly
   - then drill into `collaboration_repo_collaborators`, `collaboration_repo_invitations`, `collaboration_team_repos`, `collaboration_outside_collaborators`, and `collaboration_org_invitations` as needed
 - `Remove Carol from org-shared memory access`
-  - identify whether access comes from a direct collaborator grant, a team repo grant, or a pending invitation
+  - identify whether access comes from org default permission, a direct collaborator grant, a team repo grant, or a pending invitation
+  - inspect `collaboration_org_membership` when the repo is org-owned
+  - if org default permission still applies, remove org membership with `collaboration_org_member_remove` or `collaboration_org_membership_remove`
   - remove the actual source of access rather than guessing
 
 ## Team memory quality bar
@@ -206,6 +244,10 @@ After the repo exists:
 - use the main memory tools with explicit `repo` targeting for read and write flows
 - reuse [manual-ops.md](manual-ops.md) only if you need raw memory issue control after the repo already exists
 
+If the repo already exists under a personal owner and should become org-governed instead of creating a fresh repo:
+- use `collaboration_repo_transfer`
+- then continue with team grants and explicit `repo` targeting against the new org-owned full name
+
 ## Fallback mode
 
 If the collaboration tools are unavailable, use `gh api` against the ClawMem host; fall back to `curl` only when `gh` is unavailable or broken.

package/skills/clawmem/references/schema.md

@@ -54,7 +54,8 @@ If you create a curated memory manually, include:
 
 - Before inventing a new `kind` or `topic`, call `memory_labels`.
 - Reuse current schema when it already fits.
-- If the current schema does not fit and a new label would help future retrieval, coordination, or reuse, create it deliberately.
+- If the current schema does not fit and a new label would help future retrieval, coordination, or reuse, create one deliberate new machine-readable label.
+- Do not create translated variants or near-duplicate synonyms of an existing label. Prefer reuse first, then one canonical new label if needed.
 - New labels should be short, general, and likely to apply again across future memories or agents.
 - Do not invent random label prefixes. Schema evolution must stay within `kind:*` and `topic:*`.
 

package/src/config.test.ts

@@ -28,8 +28,8 @@ function baseConfig(): ClawMemPluginConfig {
     },
     memoryRecallLimit: 5,
     memoryAutoRecallLimit: 3,
-    turnCommentDelayMs: 1000,
     summaryWaitTimeoutMs: 120000,
+    memoryExtractWaitTimeoutMs: 45000,
   };
 }
 

package/src/config.ts

@@ -47,8 +47,8 @@ export function resolvePluginConfig(api: OpenClawPluginApi): ClawMemPluginConfig
     agents,
     memoryRecallLimit: clamp(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),
+    memoryExtractWaitTimeoutMs: clamp(num(raw.memoryExtractWaitTimeoutMs, 45000), 1000, 600000),
   };
 }
 

package/src/conversation.test.ts

@@ -1,11 +1,15 @@
 // Tests for conversation title derivation logic.
-import { deriveInitialTitle } from "./conversation.js";
-import type { NormalizedMessage } from "./types.js";
+import { ConversationMirror, buildFinalizeArtifactsPrompt, deriveInitialTitle } from "./conversation.js";
+import type { MemorySchema, NormalizedMessage, SessionMirrorState } from "./types.js";
 
 function msg(role: string, text: string): NormalizedMessage {
   return { role, text };
 }
 
+function assert(condition: unknown, message: string): void {
+  if (!condition) throw new Error(message);
+}
+
 const tests: Array<{ name: string; messages: NormalizedMessage[]; sessionId: string; expected: string }> = [
   {
     name: "returns placeholder regardless of user message content",
@@ -54,17 +58,63 @@ const tests: Array<{ name: string; messages: NormalizedMessage[]; sessionId: str
 let passed = 0;
 let failed = 0;
 
-for (const t of tests) {
-  const got = deriveInitialTitle(t.messages, t.sessionId);
-  const ok = got === t.expected;
-  if (!ok) {
-    console.error(`FAIL: ${t.name}\n  got:      ${JSON.stringify(got)}\n  expected: ${JSON.stringify(t.expected)}`);
-    failed++;
-  } else {
-    console.log(`PASS: ${t.name}`);
-    passed++;
+async function testLoadSnapshotPrefersFallbackMessages(): Promise<void> {
+  const mirror = new ConversationMirror(
+    {} as never,
+    { logger: { warn() {}, info() {} } } as never,
+    {} as never,
+  );
+  const session: SessionMirrorState = {
+    sessionId: "sync-session",
+    sessionFile: "/tmp/does-not-need-to-exist.jsonl",
+    lastMirroredCount: 0,
+    turnCount: 0,
+  };
+  const snapshot = await mirror.loadSnapshot(session, [{ role: "user", text: "Use the in-request transcript." }]);
+  assert(snapshot.messages.length === 1, "expected loadSnapshot to return fallback messages");
+  assert(snapshot.messages[0]?.text === "Use the in-request transcript.", "expected loadSnapshot to prefer in-request messages over transcript files");
+}
+
+function testBuildFinalizeArtifactsPromptIncludesSchemaReuseRules(): void {
+  const schema: MemorySchema = {
+    kinds: ["core-fact", "convention"],
+    topics: ["redis", "rate-limits"],
+  };
+  const prompt = buildFinalizeArtifactsPrompt({
+    sessionId: "finalize-session",
+    messages: [
+      msg("user", "请记住我们现在统一用 Redis 做限流。"),
+      msg("assistant", "好的，我会按这个约定处理。"),
+    ],
+  }, schema);
+
+  assert(prompt.includes("Candidate titles and details must be in the same language as the majority of the conversation content."), "expected language guidance for candidate text");
+  assert(prompt.includes("Prefer a concise explicit title for each candidate"), "expected explicit title guidance for candidates");
+  assert(prompt.includes("Reuse existing schema labels when one already fits."), "expected schema reuse guidance");
+  assert(prompt.includes("Only create a new label when none of the current labels matches"), "expected controlled schema creation guidance");
+  assert(prompt.includes("- kind:core-fact"), "expected kinds to be embedded in finalize prompt");
+  assert(prompt.includes("- topic:redis"), "expected topics to be embedded in finalize prompt");
+}
+
+async function main(): Promise<void> {
+  for (const t of tests) {
+    const got = deriveInitialTitle(t.messages, t.sessionId);
+    const ok = got === t.expected;
+    if (!ok) {
+      console.error(`FAIL: ${t.name}\n  got:      ${JSON.stringify(got)}\n  expected: ${JSON.stringify(t.expected)}`);
+      failed++;
+    } else {
+      console.log(`PASS: ${t.name}`);
+      passed++;
+    }
   }
+  await testLoadSnapshotPrefersFallbackMessages();
+  console.log("PASS: loadSnapshot prefers fallback messages");
+  testBuildFinalizeArtifactsPromptIncludesSchemaReuseRules();
+  console.log("PASS: buildFinalizeArtifactsPrompt includes schema reuse rules");
+
+  console.log(`\n${passed + 2} passed, ${failed} failed`);
+  if (failed > 0) process.exit(1);
 }
 
-console.log(`\n${passed} passed, ${failed} failed`);
-if (failed > 0) process.exit(1);
+await main();