@clawmem-ai/clawmem 0.1.11 → 0.1.13

package/README.md

@@ -137,7 +137,8 @@ Full config with all options:
           },
           turnCommentDelayMs: 1000,
           summaryWaitTimeoutMs: 120000,
-          memoryRecallLimit: 5
+          memoryRecallLimit: 5,
+          memoryAutoRecallLimit: 5
         }
       }
     }
@@ -152,7 +153,7 @@ 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"`; if backend search fails, clawmem falls back to local lexical ranking.
+- `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.
 - 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.
@@ -160,4 +161,5 @@ Full config with all options:
 - Memory issues no longer use `session:*` labels. Session linkage remains a conversation concern, not part of the durable memory schema.
 - `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.

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "clawmem",
   "name": "ClawMem",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "Mirror OpenClaw sessions into GitHub-compatible issues and comments.",
   "kind": "memory",
   "skills": [
@@ -76,6 +76,11 @@
         "type": "integer",
         "minimum": 1,
         "maximum": 20
+      },
+      "memoryAutoRecallLimit": {
+        "type": "integer",
+        "minimum": 1,
+        "maximum": 20
       }
     }
   },
@@ -118,6 +123,10 @@
     },
     "memoryRecallLimit": {
       "label": "Memory Recall Limit",
+      "help": "Default maximum number of active memories returned by memory recall tools."
+    },
+    "memoryAutoRecallLimit": {
+      "label": "Auto Recall Limit",
       "help": "Maximum number of active memories injected into context before an agent starts."
     }
   }

package/package.json

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

package/skills/clawmem/SKILL.md

@@ -46,12 +46,16 @@ 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.
+   - 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.
+   - 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, briefly surface the hit with the memory id and title when it helps the user follow the reasoning.
-   - After creating or updating a memory, announce `Locked memory #<id>: <title>` when the tool response returns an id and title.
+   - If a retrieved memory materially shaped the answer, including automatic session-start recall, 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.
 
@@ -63,11 +67,14 @@ 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.
+- Memory titles and bodies default to the user's current language for new memories.
+- 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`.
 
 ## Read the right reference
 
-- For user-facing messaging, first-run notes, memory console links, and post-save confirmations, read [references/communication.md](references/communication.md).
+- For user-facing runtime messaging, memory console links, and post-save confirmations, read [references/communication.md](references/communication.md).
 - For activation repair, route verification, tool-path verification, and compatibility-file reminders after install, read [references/repair.md](references/repair.md).
 - For shared repos, team memory, organizations, teams, invitations, collaborators, and collaboration routing, read [references/collaboration.md](references/collaboration.md).
 - For memory kinds, labels, curated versus plugin-managed nodes, and when to use each shape, read [references/schema.md](references/schema.md).

package/skills/clawmem/references/collaboration.md

@@ -96,7 +96,9 @@ Reason with these rules before every collaboration action:
 - Teams are org-scoped authorization groups, not social groups.
 - Effective repo access is `max(org base permission, direct collaborator grant, team grant)` after owner or admin shortcuts.
 - Runtime permissions are only `none`, `read`, `write`, and `admin`.
+- Organization invitation roles are `member` and `owner`.
 - `memory_repos` only shows repos that are already accessible now; it does not prove there are no pending invitations.
+- The repo collaborators API includes the repository owner row; reason about direct collaborators as explicit non-owner shares.
 - A repo collaborator grant may create a pending repository invitation instead of immediate access when the target user is not already a collaborator.
 - 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.

package/skills/clawmem/references/communication.md

@@ -1,60 +1,44 @@
-# ClawMem Communication And First-Run Messaging
+# ClawMem Runtime Communication
 
-Use this reference when you need user-facing copy after setup succeeds, need a short first-run message, want to generate a memory console link, or want stronger post-save communication after memory operations.
+Use this reference when memory shaped the answer, a memory was saved or updated, or the user needs a console link to inspect the memory graph.
 
 ## Contents
 
 - Keep the user posted
-- Restart notice protocol
-- First-run message
 - Memory visualization console
 
 ## Keep the user posted
 
 Nothing interesting should happen silently. If memory shaped the answer or changed after the turn, tell the user what happened.
 
+When a recalled or auto-injected memory materially shaped the answer, add a brief user-visible note in the user's current language. Keep it short, natural, and easy to skip.
+
 Preferred retrieval transparency:
-- `Memory hit #<id>: <title>`
+- say that you recalled or confirmed something from prior memory
+- mention the remembered fact itself
+- include the memory id and title only when they genuinely help the user follow along or when the user is debugging memory behavior
 
 Use a miss note only when the user would reasonably expect that you checked:
-- `Memory miss: no prior decision found on staging cutover`
-
-Preferred confirmation:
-- `Locked memory #<id>: <title>`
-
-Friendlier variants are fine as long as they stay truthful and short.
-
-Examples:
-- `Memory hit #14: Team demo moved to Wednesday`
-- `Locked memory #10: API rate limiting uses a sliding window policy`
-- `Locked memory #27: Client meeting is Thursday at 2pm`
+- explain in the user's current language that no relevant prior memory was found
 
-## Restart notice protocol
+When a memory is created or updated successfully, add a brief confirmation in the user's current language.
 
-If setup requires an OpenClaw gateway restart and that restart may interrupt outgoing replies, send a short notice before restarting.
-
-Suggested notice:
-
-> ClawMem is installed and selected as the active memory plugin. Restarting the OpenClaw gateway to load it now.
-> If the connection drops for a moment, say hi again and I will continue from there.
-
-## First-run message
-
-After restart completes and verification passes, use a short onboarding note. Keep it high-signal and avoid dumping the full skill into chat.
+Preferred confirmation:
+- say that you remembered, saved, or updated it
+- include the memory id and title only when they help with debugging, traceability, or explicit user requests
 
-Suggested structure:
-- ClawMem is active and now persists durable memories across sessions.
-- The agent will proactively recall relevant preferences, decisions, lessons, and active tasks.
-- The agent will tell the user when it locks a memory.
-- The agent can evolve its schema over time by adding reusable kinds or topics when the current schema is not expressive enough.
-- The user can inspect the memory graph in the console link below.
+Storage language defaults:
+- For new memories, store the human-readable title and body in the user's current language.
+- For updates, preserve the memory node's current language unless the user explicitly asks for a rewrite.
+- Keep labels and structural markers such as `type:*`, `kind:*`, and `topic:*` in their fixed machine-readable form.
 
-Optional fuller note:
+Do not force English markers like `Memory hit` or `Locked memory` in non-English conversations. Those are examples, not required phrasing.
 
-> ClawMem is active. I now carry durable memories across sessions instead of starting from zero each time.
-> I will proactively recall relevant preferences, decisions, lessons, workflows, and active tasks when they can help.
-> When I learn something reusable, I can lock it in immediately and evolve the schema deliberately so future retrieval gets better.
-> When I save something important, I will tell you. You can inspect the memory graph in the console link below.
+Examples:
+- `我从之前的记忆里确认到：你最近在看《Legal High》。`
+- `这条我记住了，之后我会按这个偏好来推荐。`
+- `I found a relevant prior memory: the team demo moved to Wednesday.`
+- `Saved that preference. I’ll use it in later recommendations.`
 
 ## Memory visualization console
 
@@ -72,7 +56,6 @@ Read `CLAWMEM_TOKEN` from the current route, substitute it into the URL, and sho
 
 ### When to show the console link
 
-- During onboarding after a successful install
 - When the user asks to view memories, the graph, or a dashboard
 - After significant memory operations, such as bulk saves
 - When a visual overview would clearly help the user

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

@@ -75,6 +75,10 @@ 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.
+- 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.
+
 ### With `gh`
 
 ```sh
@@ -85,8 +89,8 @@ done
 
 GH_HOST="$CLAWMEM_HOST" GH_ENTERPRISE_TOKEN="$CLAWMEM_TOKEN" \
   gh issue create --repo "$CLAWMEM_REPO" \
-    --title "Memory: <concise title>" \
-    --body "<durable detail in plain language>" \
+    --title "<concise title in the user's current language>" \
+    --body "<durable detail in the user's current language>" \
     --label "type:memory" \
     --label "kind:lesson"
 ```
@@ -105,8 +109,8 @@ curl -sf -X POST -H "Authorization: token $CLAWMEM_TOKEN" \
   -H "Content-Type: application/json" \
   "$CLAWMEM_BASE_URL/repos/$CLAWMEM_REPO/issues" \
   -d "{
-    \"title\": \"Memory: <concise title>\",
-    \"body\": \"<durable detail in plain language>\",
+    \"title\": \"<concise title in the user's current language>\",
+    \"body\": \"<durable detail in the user's current language>\",
     \"labels\": [\"type:memory\", \"kind:lesson\"]
   }" | jq '{number, title, url: .html_url}'
 ```

package/skills/clawmem/references/repair.md

@@ -98,7 +98,8 @@ When prior context may help, I search ClawMem before answering.
 
 ```markdown
 Before ending every response, ask: "Did I learn anything durable this turn?"
-If yes or unsure, save it to ClawMem now.
+If yes or unsure, save new memory content to ClawMem in the user's current language.
+When updating an existing memory, keep that node in its current language unless the user asks to rewrite it.
 ```
 
 ### Optional TOOLS.md reminder

package/skills/clawmem/references/schema.md

@@ -58,6 +58,12 @@ If you create a curated memory manually, include:
 - 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:*`.
 
+## Storage language
+
+- For new memory nodes, write the human-readable title and body in the user's current language by default.
+- 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.
+
 ## Storage rule
 
 If you are writing something so the agent remembers it later, store it in ClawMem. If you are writing something for a tool or human to read directly, write a file instead.

package/src/collaboration.test.ts

@@ -0,0 +1,71 @@
+import {
+  filterDirectCollaborators,
+  listRepoAccessTeams,
+  repoSummaryFullName,
+  resolveOrgInvitationRole,
+} from "./collaboration.js";
+
+function assert(condition: unknown, message: string): void {
+  if (!condition) throw new Error(message);
+}
+
+function testOrgInvitationRoleValidation(): void {
+  const fallback = resolveOrgInvitationRole(undefined, "member");
+  assert("role" in fallback && fallback.role === "member", "expected undefined role to fall back to member");
+
+  const owner = resolveOrgInvitationRole("owner", "member");
+  assert("role" in owner && owner.role === "owner", "expected owner role to pass through");
+
+  const invalid = resolveOrgInvitationRole("admin", "member");
+  assert("error" in invalid, "expected admin to be rejected because backend expects owner");
+}
+
+function testDirectCollaboratorFiltering(): void {
+  const collaborators = filterDirectCollaborators([
+    { login: "Acme" },
+    { login: "alice", outside_collaborator: true },
+    { login: "bob", organization_member: true },
+  ], "acme");
+
+  assert(collaborators.length === 2, "expected owner row to be excluded from explicit collaborators");
+  assert(collaborators[0]?.login === "alice", "expected alice to remain after owner filtering");
+  assert(collaborators[1]?.login === "bob", "expected bob to remain after owner filtering");
+}
+
+function testRepoSummaryFallback(): void {
+  assert(repoSummaryFullName({ full_name: "acme/project" }) === "acme/project", "expected explicit full_name to win");
+  assert(repoSummaryFullName({ owner: { login: "acme" }, name: "project" }) === "acme/project", "expected owner/name fallback to work");
+}
+
+async function testRepoAccessTeamsDerivation(): Promise<void> {
+  const result = await listRepoAccessTeams({
+    async listOrgTeams() {
+      return [
+        { slug: "admins", name: "admins" },
+        { slug: "writers", name: "writers" },
+        { slug: "broken", name: "broken" },
+      ];
+    },
+    async listTeamRepos(_org: string, teamSlug: string) {
+      if (teamSlug === "admins") return [{ full_name: "acme/project", role_name: "admin" }];
+      if (teamSlug === "writers") return [{ owner: { login: "acme" }, name: "project", role_name: "write" }];
+      if (teamSlug === "broken") throw new Error("boom");
+      return [];
+    },
+  }, "acme", "acme/project");
+
+  assert(result.teams.length === 2, "expected two teams with access to be discovered via org->team->repo traversal");
+  assert(result.teams[0]?.slug === "admins", "expected admins team to be included");
+  assert(result.teams[1]?.slug === "writers", "expected writers team to be included");
+  assert(result.notes.length === 1 && result.notes[0]?.includes("broken"), "expected per-team lookup failures to be recorded as notes");
+}
+
+async function main(): Promise<void> {
+  testOrgInvitationRoleValidation();
+  testDirectCollaboratorFiltering();
+  testRepoSummaryFallback();
+  await testRepoAccessTeamsDerivation();
+  console.log("collaboration tests passed");
+}
+
+await main();

package/src/collaboration.ts

@@ -0,0 +1,109 @@
+export type CollaborationPermission = "read" | "write" | "admin";
+export type CollaborationOrgInvitationRole = "member" | "owner";
+
+type PermissionMap = Record<string, boolean | undefined>;
+
+export type CollaborationRepoSummary = {
+  full_name?: string;
+  owner?: { login?: string };
+  name?: string;
+  permissions?: PermissionMap;
+  role_name?: string;
+};
+
+export type CollaborationTeamSummary = {
+  id?: number;
+  slug?: string;
+  name?: string;
+  description?: string;
+  privacy?: string;
+  permission?: string;
+  role_name?: string;
+  permissions?: PermissionMap;
+};
+
+export type CollaborationCollaboratorSummary = {
+  id?: number;
+  login?: string;
+  name?: string;
+  permissions?: PermissionMap;
+  role_name?: string;
+  organization_member?: boolean;
+  outside_collaborator?: boolean;
+  type?: string;
+};
+
+type RepoAccessTeamClient = {
+  listOrgTeams(org: string): Promise<CollaborationTeamSummary[]>;
+  listTeamRepos(org: string, teamSlug: string): Promise<CollaborationRepoSummary[]>;
+};
+
+export function normalizePermissionAlias(value: unknown): "none" | CollaborationPermission | undefined {
+  if (typeof value !== "string") return undefined;
+  const normalized = value.trim().toLowerCase();
+  if (!normalized) return undefined;
+  if (normalized === "none") return "none";
+  if (normalized === "read" || normalized === "pull" || normalized === "triage") return "read";
+  if (normalized === "write" || normalized === "push" || normalized === "maintain") return "write";
+  if (normalized === "admin") return "admin";
+  return undefined;
+}
+
+export function resolveOrgInvitationRole(
+  value: unknown,
+  fallback: CollaborationOrgInvitationRole,
+): { role: CollaborationOrgInvitationRole } | { error: string } {
+  if (value === undefined || value === null || value === "") return { role: fallback };
+  if (typeof value !== "string") return { error: "role must be member or owner." };
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "member" || normalized === "owner") return { role: normalized };
+  return { error: `Unsupported role "${value}". Use member or owner.` };
+}
+
+export function repoSummaryFullName(repo?: CollaborationRepoSummary): string | undefined {
+  const fullName = repo?.full_name?.trim();
+  if (fullName) return fullName;
+  const owner = repo?.owner?.login?.trim();
+  const name = repo?.name?.trim();
+  if (owner && name) return `${owner}/${name}`;
+  return name || undefined;
+}
+
+export function filterDirectCollaborators(
+  collaborators: CollaborationCollaboratorSummary[],
+  ownerLogin: string,
+): CollaborationCollaboratorSummary[] {
+  const owner = ownerLogin.trim().toLowerCase();
+  if (!owner) return collaborators;
+  return collaborators.filter((collaborator) => (collaborator.login?.trim().toLowerCase() || "") !== owner);
+}
+
+export async function listRepoAccessTeams(
+  client: RepoAccessTeamClient,
+  org: string,
+  fullName: string,
+): Promise<{ teams: CollaborationTeamSummary[]; notes: string[] }> {
+  const notes: string[] = [];
+  const teams = await client.listOrgTeams(org);
+  const withAccess: CollaborationTeamSummary[] = [];
+  for (const team of teams) {
+    const teamSlug = team.slug?.trim() || team.name?.trim();
+    if (!teamSlug) {
+      notes.push(`Skipped a team in org "${org}" because it had no slug or name.`);
+      continue;
+    }
+    try {
+      const repos = await client.listTeamRepos(org, teamSlug);
+      const matchingRepo = repos.find((repo) => repoSummaryFullName(repo) === fullName);
+      if (!matchingRepo) continue;
+      withAccess.push({
+        ...team,
+        ...(matchingRepo.permissions ? { permissions: matchingRepo.permissions } : {}),
+        ...(matchingRepo.role_name ? { role_name: matchingRepo.role_name } : {}),
+      });
+    } catch (error) {
+      notes.push(`Team repo lookup failed for ${org}/${teamSlug}: ${String(error)}`);
+    }
+  }
+  return { teams: withAccess, notes };
+}

package/src/config.test.ts

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

package/src/config.ts

@@ -12,13 +12,14 @@ export const LABEL_CLOSED = "status:closed";
 export const LABEL_MEMORY_ACTIVE = "memory-status:active";
 export const LABEL_MEMORY_STALE = "memory-status:stale";
 
-const MANAGED_PREFIXES = ["type:", "kind:", "session:", "date:", "topic:", "agent:", "source:"];
+const MANAGED_PREFIXES = ["type:", "kind:", "session:", "date:", "topic:", "agent:"];
 const MANAGED_EXACT = new Set([LABEL_ACTIVE, LABEL_CLOSED, LABEL_MEMORY_ACTIVE, LABEL_MEMORY_STALE]);
 
 export function resolvePluginConfig(api: OpenClawPluginApi): ClawMemPluginConfig {
   const raw = (api.pluginConfig ?? {}) as Record<string, unknown>;
   const str = (v: unknown) => typeof v === "string" && v.trim() ? v.trim() : undefined;
   const num = (v: unknown, d: number) => typeof v === "number" && Number.isFinite(v) ? Math.floor(v) : d;
+  const float = (v: unknown, d: number) => typeof v === "number" && Number.isFinite(v) ? v : d;
   const clamp = (v: number, lo: number, hi: number) => Math.min(hi, Math.max(lo, v));
   const baseUrl = (str(raw.baseUrl) ?? "https://git.clawmem.ai").replace(/\/+$/, "");
   const rawAgents = raw.agents && typeof raw.agents === "object" && !Array.isArray(raw.agents)
@@ -45,6 +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),
     turnCommentDelayMs: num(raw.turnCommentDelayMs, 1000),
     summaryWaitTimeoutMs: clamp(num(raw.summaryWaitTimeoutMs, 120000), 1000, 600000),
   };
@@ -83,14 +85,13 @@ export function resolveLabelColor(label: string): string {
   if (label.startsWith("topic:")) return "fbca04";
   if (label.startsWith("session:")) return "bfdadc";
   if (label.startsWith("agent:")) return "1d76db";
-  if (label.startsWith("source:")) return "0e8a16";
   return "0e8a16";
 }
 
 export function labelDescription(label: string): string {
   for (const [pfx, d] of [["type:", "Issue type"], ["kind:", "Memory kind"], ["memory-status:", "Memory lifecycle status"],
     ["status:", "Conversation lifecycle status"], ["session:", "Session association"],
-    ["date:", "Date"], ["topic:", "Topic"], ["agent:", "Agent"], ["source:", "Source"]] as const)
+    ["date:", "Date"], ["topic:", "Topic"], ["agent:", "Agent"]] as const)
     if (label.startsWith(pfx)) return `${d} label managed by clawmem.`;
   return "Label managed by clawmem.";
 }

package/src/github-client.ts

@@ -39,6 +39,9 @@ type CollaboratorResponse = {
   name?: string;
   permissions?: PermissionMap;
   role_name?: string;
+  organization_member?: boolean;
+  outside_collaborator?: boolean;
+  type?: string;
 };
 type RepositoryInvitationResponse = {
   id?: number;
@@ -209,9 +212,6 @@ export class GitHubIssueClient {
   async getRepo(owner: string, repo: string): Promise<RepoResponse> {
     return this.req<RepoResponse>(`repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`, { method: "GET" });
   }
-  async listRepoTeams(owner: string, repo: string): Promise<TeamResponse[]> {
-    return this.req<TeamResponse[]>(`repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/teams`, { method: "GET" });
-  }
   async listUserRepoInvitations(): Promise<RepositoryInvitationResponse[]> {
     return this.req<RepositoryInvitationResponse[]>("user/repository_invitations", { method: "GET" });
   }
@@ -226,7 +226,7 @@ export class GitHubIssueClient {
   }
   async createOrgInvitation(
     org: string,
-    params: { inviteeLogin: string; role?: "member" | "admin"; teamIds?: number[]; expiresInDays?: number },
+    params: { inviteeLogin: string; role?: "member" | "owner"; teamIds?: number[]; expiresInDays?: number },
   ): Promise<InvitationResponse> {
     return this.req<InvitationResponse>(`orgs/${encodeURIComponent(org)}/invitations`, {
       method: "POST",

package/src/memory.test.ts

@@ -41,6 +41,15 @@ function assert(condition: unknown, message: string): void {
   if (!condition) throw new Error(message);
 }
 
+function testConfig(): never {
+  return {
+    memoryRecallLimit: 5,
+    memoryAutoRecallLimit: 5,
+    turnCommentDelayMs: 1000,
+    summaryWaitTimeoutMs: 120000,
+  } as never;
+}
+
 async function testSearchRanking(): Promise<void> {
   const issues = [
     issueFromMemory(memory({
@@ -60,7 +69,7 @@ async function testSearchRanking(): Promise<void> {
   const client = {
     listIssues: async () => issues,
   };
-  const store = new MemoryStore(client as never, {} as never, { memoryRecallLimit: 5, turnCommentDelayMs: 1000, summaryWaitTimeoutMs: 120000 } as never);
+  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");
@@ -93,7 +102,7 @@ async function testBackendSearchPreferredForRecall(): Promise<void> {
       return searched;
     },
   };
-  const store = new MemoryStore(client as never, {} as never, { memoryRecallLimit: 5, turnCommentDelayMs: 1000, summaryWaitTimeoutMs: 120000 } as never);
+  const store = new MemoryStore(client as never, {} as never, testConfig());
   const found = await store.search("redis rate limiting", 5);
 
   assert(queries.length === 1, "expected backend search to be called once");
@@ -117,7 +126,7 @@ async function testBackendSearchFallsBackToLocalLexical(): Promise<void> {
     listIssues: async () => issues,
     searchIssues: async () => { throw new Error("search unavailable"); },
   };
-  const store = new MemoryStore(client as never, { logger: { warn: () => {} } } as never, { memoryRecallLimit: 5, turnCommentDelayMs: 1000, summaryWaitTimeoutMs: 120000 } as never);
+  const store = new MemoryStore(client as never, { logger: { warn: () => {} } } 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");
@@ -155,7 +164,7 @@ async function testStructuredStoreAndSchema(): Promise<void> {
       return { number: 99, title: payload.title };
     },
   };
-  const store = new MemoryStore(client as never, {} as never, { memoryRecallLimit: 5, turnCommentDelayMs: 1000, summaryWaitTimeoutMs: 120000 } as never);
+  const store = new MemoryStore(client as never, {} as never, testConfig());
   const result = await store.store({ detail: "Redis Lua scripts are required for atomic rate limiting.", kind: "Lesson", topics: ["Redis Ops", "rate_limit"] });
   const schema = await store.listSchema();
 
@@ -211,7 +220,7 @@ async function testGetAndListMemories(): Promise<void> {
       });
     },
   };
-  const store = new MemoryStore(client as never, {} as never, { memoryRecallLimit: 5, turnCommentDelayMs: 1000, summaryWaitTimeoutMs: 120000 } as never);
+  const store = new MemoryStore(client as never, {} as never, testConfig());
   const exact = await store.get("4");
   const activeFacts = await store.listMemories({ status: "active", kind: "core-fact", limit: 10 });
   const sports = await store.listMemories({ status: "all", topic: "sports", limit: 10 });
@@ -243,7 +252,7 @@ async function testLegacyMemoriesWithoutSessionOrDate(): Promise<void> {
       });
     },
   };
-  const store = new MemoryStore(client as never, {} as never, { memoryRecallLimit: 5, turnCommentDelayMs: 1000, summaryWaitTimeoutMs: 120000 } as never);
+  const store = new MemoryStore(client as never, {} as never, testConfig());
   const exact = await store.get("4");
   const recalled = await store.search("F1 Dota 2", 5);
 
@@ -292,7 +301,7 @@ async function testUpdateMemoryInPlace(): Promise<void> {
       issue.labels = labels;
     },
   };
-  const store = new MemoryStore(client as never, {} as never, { memoryRecallLimit: 5, turnCommentDelayMs: 1000, summaryWaitTimeoutMs: 120000 } as never);
+  const store = new MemoryStore(client as never, {} as never, testConfig());
   const updated = await store.update("4", {
     detail: "xiangz likes F1, watches Dota 2 as a viewer, and recently follows tennis.",
     topics: ["preferences", "sports"],
@@ -344,7 +353,7 @@ async function testForgetClosesMemoryIssue(): Promise<void> {
       return issue;
     },
   };
-  const store = new MemoryStore(client as never, {} as never, { memoryRecallLimit: 5, turnCommentDelayMs: 1000, summaryWaitTimeoutMs: 120000 } as never);
+  const store = new MemoryStore(client as never, {} as never, testConfig());
   const forgotten = await store.forget("12");
 
   assert(forgotten?.status === "stale", "expected forgotten memory to be returned as stale");

package/src/memory.ts

@@ -3,7 +3,7 @@ import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
 import { LABEL_MEMORY_STALE, MEMORY_TITLE_PREFIX, extractLabelNames, labelVal } from "./config.js";
 import type { GitHubIssueClient } from "./github-client.js";
 import { normalizeMessages } from "./transcript.js";
-import type { ClawMemPluginConfig, MemoryDraft, MemoryListOptions, MemorySchema, NormalizedMessage, ParsedMemoryIssue, SessionMirrorState, TranscriptSnapshot } from "./types.js";
+import type { ClawMemPluginConfig, MemoryDraft, MemoryListOptions, MemorySchema, ParsedMemoryIssue, SessionMirrorState, TranscriptSnapshot } from "./types.js";
 import { fmtTranscript, localDate, sha256, subKey } from "./utils.js";
 import { parseFlatYaml, stringifyFlatYaml } from "./yaml.js";
 
@@ -206,7 +206,8 @@ export class MemoryStore {
     const status = issue.state === "closed" || labels.includes(LABEL_MEMORY_STALE) ? "stale" : "active";
     if (!detail) return null;
     return {
-      issueNumber: issue.number, title: issue.title?.trim() || "",
+      issueNumber: issue.number,
+      title: issue.title?.trim() || "",
       memoryId: body.memory_id?.trim() || String(issue.number),
       memoryHash: body.memory_hash?.trim() || undefined,
       date: body.date?.trim() || "1970-01-01",
@@ -280,6 +281,7 @@ export class MemoryStore {
     const message = [
       "Extract durable memories from the conversation below.",
       'Return JSON only in the form {"save":[{"detail":"...","kind":"...","topics":["..."]}],"stale":["memory-id"]}.',
+      "Each save item must contain one durable fact. If a turn contains several independent facts, save them separately instead of bundling them into one summary memory.",
       "Use save for stable, reusable facts, preferences, decisions, constraints, workflows, and ongoing context worth remembering later.",
       "Use stale for existing memory IDs only when the conversation clearly supersedes or invalidates them.",
       "Infer kind and topics when they would help future retrieval. Reuse existing kinds and topics when possible.",
@@ -293,9 +295,12 @@ export class MemoryStore {
     ].join("\n");
     try {
       const run = await subagent.run({
-        sessionKey, message, deliver: false, lane: "clawmem-memory",
+        sessionKey,
+        message,
+        deliver: false,
+        lane: "clawmem-memory",
         idempotencyKey: sha256(`${session.sessionId}:${snapshot.messages.length}:memory-decision`),
-        extraSystemPrompt: "You extract durable memory updates from OpenClaw conversations. Output JSON only with save objects containing detail, optional kind, and optional topics, plus stale string ids.",
+        extraSystemPrompt: "You extract durable memory updates from OpenClaw conversations. Output JSON only with save objects containing detail, optional kind, and optional topics, plus stale string ids. Keep each save item to one durable fact.",
       });
       const wait = await subagent.waitForRun({ runId: run.runId, timeoutMs: this.config.summaryWaitTimeoutMs });
       if (wait.status === "timeout") throw new Error("memory decision subagent timed out");
@@ -304,7 +309,9 @@ export class MemoryStore {
       const text = [...msgs].reverse().find((e) => e.role === "assistant" && e.text.trim())?.text;
       if (!text) throw new Error("memory decision subagent returned no assistant text");
       return parseDecision(text);
-    } finally { subagent.deleteSession({ sessionKey, deleteTranscript: true }).catch(() => {}); }
+    } finally {
+      subagent.deleteSession({ sessionKey, deleteTranscript: true }).catch(() => {});
+    }
   }
 
   private async mergeSchema(memory: ParsedMemoryIssue, draft: MemoryDraft): Promise<ParsedMemoryIssue> {
@@ -333,11 +340,13 @@ function memLabels(kind?: string, topics?: string[]): string[] {
     ...((topics ?? []).map((topic) => `topic:${topic}`)),
   ];
 }
+
 function norm(v: string): string { return v.replace(/\s+/g, " ").trim(); }
 function trunc(v: string, max: number): string { const s = norm(v); return s.length <= max ? s : `${s.slice(0, max - 1).trimEnd()}…`; }
 function normalizeSearch(v: string): string {
   return v.normalize("NFKC").toLowerCase().replace(/\s+/g, " ").trim();
 }
+
 function buildSearchIndex(memory: ParsedMemoryIssue): SearchIndex {
   return {
     title: normalizeSearch(memory.title),
@@ -346,6 +355,7 @@ function buildSearchIndex(memory: ParsedMemoryIssue): SearchIndex {
     topics: (memory.topics ?? []).map(normalizeSearch).filter(Boolean),
   };
 }
+
 function searchTokens(v: string): string[] {
   const seen = new Set<string>();
   for (const token of v.split(/[^0-9\p{L}]+/u)) {
@@ -359,6 +369,7 @@ function searchTokens(v: string): string[] {
   }
   return [...seen];
 }
+
 function charBigrams(v: string): Set<string> {
   const compact = v.replace(/\s+/g, "");
   if (compact.length < 2) return new Set(compact ? [compact] : []);
@@ -366,16 +377,19 @@ function charBigrams(v: string): Set<string> {
   for (let i = 0; i < compact.length - 1; i++) out.add(compact.slice(i, i + 2));
   return out;
 }
+
 function overlapRatio(left: Set<string>, right: Set<string>): number {
   if (left.size === 0 || right.size === 0) return 0;
   let hits = 0;
   for (const token of left) if (right.has(token)) hits++;
   return hits / Math.max(left.size, right.size);
 }
+
 function buildMemorySearchQuery(query: string, repo: string): string {
   const parts = [query.trim(), `repo:${repo}`, "is:issue", "state:open", 'label:"type:memory"'].filter(Boolean);
   return parts.join(" ");
 }
+
 export function scoreMemoryMatch(memory: ParsedMemoryIssue, rawQuery: string): number {
   const query = normalizeSearch(rawQuery);
   if (!query) return 0;
@@ -411,6 +425,7 @@ export function scoreMemoryMatch(memory: ParsedMemoryIssue, rawQuery: string): n
 
   return score;
 }
+
 function normalizeDraft(input: MemoryDraft): MemoryDraft {
   const detail = norm(input.detail);
   if (!detail) throw new Error("memory detail is empty");
@@ -422,6 +437,7 @@ function normalizeDraft(input: MemoryDraft): MemoryDraft {
     ...(topics.length > 0 ? { topics } : {}),
   };
 }
+
 function normalizeLabelValue(value: string | undefined, prefix: string): string | undefined {
   if (!value) return undefined;
   const raw = value.trim().replace(new RegExp(`^${prefix}`, "i"), "");
@@ -433,6 +449,7 @@ function normalizeLabelValue(value: string | undefined, prefix: string): string
     .replace(/^-+|-+$/g, "");
   return normalized || undefined;
 }
+
 function normalizeOptionalLabelValue(value: string | undefined, prefix: string): string | undefined {
   try {
     return normalizeLabelValue(value, prefix);
@@ -440,16 +457,22 @@ function normalizeOptionalLabelValue(value: string | undefined, prefix: string):
     return undefined;
   }
 }
+
 function uniqueNormalized(values: string[]): string[] {
   return [...new Set(values.map((value) => value.trim()).filter(Boolean))].sort();
 }
+
 function parseDecision(raw: string): MemoryDecision {
   const tryParse = (s: string): MemoryDecision | null => {
     try {
       const p = JSON.parse(s) as Record<string, unknown>;
-      return { save: Array.isArray(p.save) ? p.save.map(parseSaveItem).filter((v): v is MemoryDraft => Boolean(v)) : [],
-               stale: Array.isArray(p.stale) ? p.stale.filter((v): v is string => typeof v === "string") : [] };
-    } catch { return null; }
+      return {
+        save: Array.isArray(p.save) ? p.save.map(parseSaveItem).filter((v): v is MemoryDraft => Boolean(v)) : [],
+        stale: Array.isArray(p.stale) ? p.stale.filter((v): v is string => typeof v === "string") : [],
+      };
+    } catch {
+      return null;
+    }
   };
   const t = raw.trim();
   return tryParse(t) ?? (() => {
@@ -459,6 +482,7 @@ function parseDecision(raw: string): MemoryDecision {
     throw new Error("memory decision subagent returned invalid JSON");
   })();
 }
+
 function parseSaveItem(value: unknown): MemoryDraft | null {
   if (typeof value === "string") {
     const detail = norm(value);

package/src/service.ts

@@ -1,6 +1,7 @@
 // Thin orchestrator: wires conversation mirroring, memory store, and plugin lifecycle.
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
 import { hasDefaultRepo, isAgentConfigured, resolveAgentRoute, resolvePluginConfig } from "./config.js";
+import { filterDirectCollaborators, listRepoAccessTeams, resolveOrgInvitationRole } from "./collaboration.js";
 import { ConversationMirror } from "./conversation.js";
 import { GitHubIssueClient } from "./github-client.js";
 import { KeyedAsyncQueue } from "./keyed-async-queue.js";
@@ -13,15 +14,17 @@ import { buildAgentBootstrapRegistration, inferAgentIdFromTranscriptPath, normal
 type TurnPayload = { sessionId?: string; sessionKey?: string; agentId?: string; messages: unknown[] };
 type FinalizePayload = { sessionId?: string; sessionKey?: string; sessionFile?: string; agentId?: string; reason?: string; messages?: unknown[] };
 type CollaborationPermission = "read" | "write" | "admin";
-type CollaborationOrgRole = "member" | "admin";
 type CollaborationTeamRole = "member" | "maintainer";
 
+const SESSION_MAINTENANCE_RETRY_DELAYS_MS = [5000, 30000, 120000] as const;
+
 class ClawMemService {
   private readonly config: ClawMemPluginConfig;
   private readonly queue = new KeyedAsyncQueue();
   private readonly stateQueue = new KeyedAsyncQueue();
   private readonly pending = new Set<Promise<unknown>>();
   private readonly syncTimers = new Map<string, ReturnType<typeof setTimeout>>();
+  private readonly maintenanceTimers = new Map<string, ReturnType<typeof setTimeout>>();
   private statePath = "";
   private state: PluginState = { version: 2, sessions: {} };
   private unsubTranscript?: () => void;
@@ -62,6 +65,8 @@ class ClawMemService {
         this.unsubTranscript?.();
         for (const t of this.syncTimers.values()) clearTimeout(t);
         this.syncTimers.clear();
+        for (const t of this.maintenanceTimers.values()) clearTimeout(t);
+        this.maintenanceTimers.clear();
         await Promise.allSettled([...this.pending]);
       },
     });
@@ -224,7 +229,7 @@ class ClawMemService {
 
     this.api.registerTool({
       name: "memory_recall",
-      description: "Search ClawMem active memories for relevant prior facts, decisions, conventions, and lessons.",
+      description: "Search ClawMem active memories for relevant prior facts, decisions, conventions, and lessons. Use this before answering questions about prior conversations, earlier assistant responses, user preferences, or historical project context.",
       required: true,
       parameters: {
         type: "object",
@@ -287,7 +292,7 @@ class ClawMemService {
 
     this.api.registerTool({
       name: "memory_store",
-      description: "Store a durable ClawMem memory immediately instead of waiting for session finalization.",
+      description: "Store one atomic durable ClawMem memory immediately instead of waiting for session finalization. Keep each write to a single fact, preference, decision, or timeline update.",
       required: true,
       parameters: {
         type: "object",
@@ -316,7 +321,11 @@ class ClawMemService {
         if ("error" in resolved) return toolText(resolved.error);
         const kind = typeof p.kind === "string" && p.kind.trim() ? p.kind.trim() : undefined;
         const topics = Array.isArray(p.topics) ? p.topics.filter((topic): topic is string => typeof topic === "string" && topic.trim().length > 0) : undefined;
-        const result = await resolved.mem.store({ detail, ...(kind ? { kind } : {}), ...(topics && topics.length > 0 ? { topics } : {}) });
+        const result = await resolved.mem.store({
+          detail,
+          ...(kind ? { kind } : {}),
+          ...(topics && topics.length > 0 ? { topics } : {}),
+        });
         if (!result.created) return toolText(`Memory already exists in ${resolved.route.repo}.\n${renderMemoryBlock(result.memory)}`);
         return toolText(`Stored memory in ${resolved.route.repo}.\n${renderMemoryBlock(result.memory)}`);
       },
@@ -1006,7 +1015,7 @@ class ClawMemService {
         properties: {
           org: { type: "string", minLength: 1, description: "Organization login." },
           inviteeLogin: { type: "string", minLength: 1, description: "Username to invite." },
-          role: { type: "string", enum: ["member", "admin"], description: "Org role for the invitation. Defaults to member." },
+          role: { type: "string", enum: ["member", "owner"], description: "Org role for the invitation. Defaults to member." },
           teamIds: {
             type: "array",
             description: "Optional numeric team ids to pre-assign on acceptance.",
@@ -1027,7 +1036,8 @@ class ClawMemService {
         const org = typeof p.org === "string" ? p.org.trim() : "";
         const inviteeLogin = typeof p.inviteeLogin === "string" ? p.inviteeLogin.trim() : "";
         if (!org || !inviteeLogin) return toolText("org and inviteeLogin are required.");
-        const role: CollaborationOrgRole = p.role === "admin" ? "admin" : "member";
+        const role = resolveOrgInvitationRole(p.role, "member");
+        if ("error" in role) return toolText(role.error);
         const teamIds = Array.isArray(p.teamIds)
           ? p.teamIds.filter((value): value is number => typeof value === "number" && Number.isInteger(value) && value > 0)
           : undefined;
@@ -1039,7 +1049,7 @@ class ClawMemService {
         try {
           const invitation = await resolved.client.createOrgInvitation(org, {
             inviteeLogin,
-            role,
+            role: role.role,
             ...(teamIds && teamIds.length > 0 ? { teamIds } : {}),
             ...(expiresInDays ? { expiresInDays } : {}),
           });
@@ -1228,9 +1238,9 @@ class ClawMemService {
           }
 
           try {
-            const collaborators = await target.client.listRepoCollaborators(target.owner, target.repo);
+            const collaborators = filterDirectCollaborators(await target.client.listRepoCollaborators(target.owner, target.repo), target.owner);
             lines.push("");
-            lines.push("Direct collaborators:");
+            lines.push("Explicit collaborators (excluding owner):");
             if (collaborators.length === 0) lines.push("- None visible");
             else lines.push(...collaborators.map((collaborator) => `- ${renderCollaboratorLine(collaborator)}`));
           } catch (error) {
@@ -1247,14 +1257,17 @@ class ClawMemService {
             notes.push(`Repo invitation lookup failed: ${String(error)}`);
           }
 
-          try {
-            const teams = await target.client.listRepoTeams(target.owner, target.repo);
-            lines.push("");
-            lines.push("Teams with repo access:");
-            if (teams.length === 0) lines.push("- None visible");
-            else lines.push(...teams.map((team) => `- ${renderTeamLine(team)}`));
-          } catch (error) {
-            notes.push(`Repo team grant lookup failed: ${String(error)}`);
+          if (orgName) {
+            try {
+              const teamAccess = await listRepoAccessTeams(target.client, orgName, target.fullName);
+              lines.push("");
+              lines.push("Teams with repo access:");
+              if (teamAccess.teams.length === 0) lines.push("- None visible");
+              else lines.push(...teamAccess.teams.map((team) => `- ${renderTeamLine(team)}`));
+              notes.push(...teamAccess.notes);
+            } catch (error) {
+              notes.push(`Repo team grant lookup failed: ${String(error)}`);
+            }
           }
 
           try {
@@ -1283,13 +1296,13 @@ class ClawMemService {
   private async handleBeforeAgentStart(prompt: unknown, agentId?: string): Promise<{ prependContext: string } | void> {
     const routeAgentId = normalizeAgentId(agentId);
     if (!(await this.ensureDefaultRepoConfigured(routeAgentId))) return;
-    await this.runRequestMaintenance(routeAgentId);
+    this.scheduleRecentSessionMaintenance(routeAgentId);
     if (typeof prompt !== "string" || prompt.trim().length < 5) return;
     try {
       const { mem } = this.getServices(routeAgentId);
-      const memories = await mem.search(prompt, this.config.memoryRecallLimit);
+      const memories = await mem.search(prompt, this.config.memoryAutoRecallLimit);
       if (memories.length === 0) return;
-      const text = memories.map((m) => `- ${m.detail}`).join("\n");
+      const text = memories.map((m) => `- ${formatInjectedMemory(m)}`).join("\n");
       return { prependContext: `<relevant-memories>\nThe following active memories may be relevant to this conversation:\n${text}\n</relevant-memories>` };
     } catch (error) { this.api.logger.warn(`clawmem: memory recall failed: ${String(error)}`); }
   }
@@ -1357,6 +1370,7 @@ class ClawMemService {
   private async finalize(p: FinalizePayload): Promise<void> {
     if (!p.sessionId) return;
     const agentId = normalizeAgentId(p.agentId);
+    const scopeKey = sessionScopeKey(p.sessionId, agentId);
     if (!(await this.ensureDefaultRepoConfigured(agentId))) return;
     const { conv } = this.getServices(agentId);
     const s = this.getOrCreate(p.sessionId, agentId);
@@ -1375,6 +1389,7 @@ class ClawMemService {
     s.summaryStatus = "pending";
     if (allOk) s.finalizedAt = new Date().toISOString();
     await this.persistState();
+    this.scheduleSessionMaintenance(scopeKey, agentId, { reason: p.reason ?? "finalize" });
   }
 
   // --- Infrastructure ---
@@ -1531,55 +1546,109 @@ class ClawMemService {
       },
     });
   }
-  private async runRequestMaintenance(agentId: string): Promise<void> {
+  private scheduleRecentSessionMaintenance(agentId: string): void {
     const sessions = Object.values(this.state.sessions)
       .filter((session) => normalizeAgentId(session.agentId) === agentId)
       .sort((a, b) => Date.parse(b.updatedAt ?? b.createdAt ?? "") - Date.parse(a.updatedAt ?? a.createdAt ?? ""))
       .slice(0, 8);
-    if (sessions.length === 0) return;
+    for (const session of sessions) {
+      if (!this.sessionNeedsMaintenance(session)) continue;
+      this.scheduleSessionMaintenance(sessionScopeKey(session.sessionId, session.agentId), agentId, {
+        reason: "request-start-fallback",
+        delayMs: 0,
+      });
+      break;
+    }
+  }
+
+  private scheduleSessionMaintenance(
+    scopeKey: string,
+    agentId: string,
+    options: { delayMs?: number; attempt?: number; reason?: string } = {},
+  ): void {
+    const prev = this.maintenanceTimers.get(scopeKey);
+    if (prev) clearTimeout(prev);
+    const delayMs = Math.max(0, options.delayMs ?? 0);
+    const attempt = Math.max(0, options.attempt ?? 0);
+    const reason = options.reason ?? "scheduled";
+    const timer = setTimeout(() => {
+      this.maintenanceTimers.delete(scopeKey);
+      void this.track(this.enqueueSession(scopeKey, () => this.runSessionMaintenance(scopeKey, agentId, attempt, reason)))
+        .catch((error) => this.warn(`background maintenance for ${scopeKey}`, error));
+    }, delayMs);
+    timer.unref?.();
+    this.maintenanceTimers.set(scopeKey, timer);
+  }
+
+  private async runSessionMaintenance(scopeKey: string, agentId: string, attempt: number, reason: string): Promise<void> {
+    const session = this.state.sessions[scopeKey];
+    if (!session || !this.sessionNeedsMaintenance(session)) return;
+    if (!(await this.ensureDefaultRepoConfigured(agentId))) return;
     const { conv, mem } = this.getServices(agentId);
+    const snap = await conv.loadSnapshot(session, []);
+    if (!conv.shouldMirror(session.sessionId, snap.messages) || snap.messages.length === 0) return;
     let changed = false;
-    let workDone = 0;
-    for (const session of sessions) {
-      if (workDone >= 3) break;
-      const snap = await conv.loadSnapshot(session, []);
-      if (!conv.shouldMirror(session.sessionId, snap.messages) || snap.messages.length === 0) continue;
-      if (!session.issueNumber) {
-        await conv.ensureIssue(session, snap);
-        changed = true;
-      }
-      if (session.summaryStatus === "pending") {
-        try {
-          const result = await conv.generateSummaryAndTitle(session, snap);
-          await conv.syncLabels(session, snap, true);
-          await conv.syncBody(session, snap, result.summary, true, result.title);
-          session.summaryStatus = "complete";
-          if (result.title?.trim()) {
-            session.issueTitle = result.title.trim();
-            session.titleSource = "llm";
-          }
-          this.maybeAutoNameRepo(agentId, result.summary, result.title);
-          changed = true;
-          workDone++;
-        } catch (error) {
-          this.warn(`request-scoped summary sync for ${session.sessionId}`, error);
+    let retryNeeded = false;
+    if (!session.issueNumber) {
+      await conv.ensureIssue(session, snap);
+      changed = true;
+    }
+    if (session.summaryStatus === "pending") {
+      try {
+        const result = await conv.generateSummaryAndTitle(session, snap);
+        await conv.syncLabels(session, snap, true);
+        await conv.syncBody(session, snap, result.summary, true, result.title);
+        session.summaryStatus = "complete";
+        if (result.title?.trim()) {
+          session.issueTitle = result.title.trim();
+          session.titleSource = "llm";
         }
+        this.maybeAutoNameRepo(agentId, result.summary, result.title);
+        changed = true;
+      } catch (error) {
+        retryNeeded = true;
+        this.warn(`background summary sync for ${session.sessionId}`, error);
       }
-      if (session.titleSource !== "llm" && snap.messages.length >= 2) {
+    }
+    if (session.titleSource !== "llm" && snap.messages.length >= 2) {
+      try {
         await conv.syncTitle(session, snap);
         changed = true;
-        workDone++;
+      } catch (error) {
+        retryNeeded = true;
+        this.warn(`background title sync for ${session.sessionId}`, error);
       }
-      if (snap.messages.length >= 2 && snap.messages.length > (session.lastMemorySyncCount ?? 0)) {
-        const ok = await mem.syncFromConversation(session, snap);
-        if (ok) {
-          session.lastMemorySyncCount = snap.messages.length;
-          changed = true;
-        }
-        workDone++;
+    }
+    if (snap.messages.length >= 2 && snap.messages.length > (session.lastMemorySyncCount ?? 0)) {
+      const ok = await mem.syncFromConversation(session, snap);
+      if (ok) {
+        session.lastMemorySyncCount = snap.messages.length;
+        changed = true;
+      } else {
+        retryNeeded = true;
       }
     }
     if (changed) await this.persistState();
+    if (!retryNeeded || !this.sessionNeedsMaintenance(session)) return;
+    if (attempt < SESSION_MAINTENANCE_RETRY_DELAYS_MS.length) {
+      const delayMs = SESSION_MAINTENANCE_RETRY_DELAYS_MS[attempt];
+      this.api.logger.warn?.(
+        `clawmem: background maintenance incomplete for ${session.sessionId}; retrying in ${Math.round(delayMs / 1000)}s (${reason})`,
+      );
+      this.scheduleSessionMaintenance(scopeKey, agentId, { delayMs, attempt: attempt + 1, reason: "retry" });
+      return;
+    }
+    this.api.logger.warn?.(
+      `clawmem: background maintenance remains pending for ${session.sessionId}; it will be retried opportunistically on future requests`,
+    );
+  }
+
+  private sessionNeedsMaintenance(session: SessionMirrorState): boolean {
+    if (session.summaryStatus === "pending") return true;
+    const hasMeaningfulTranscript = Math.max(session.lastMirroredCount, session.turnCount) >= 2;
+    if (!hasMeaningfulTranscript) return false;
+    if (session.titleSource !== "llm") return true;
+    return (session.lastMemorySyncCount ?? 0) < session.lastMirroredCount;
   }
 
   private getServices(agentId?: string, repo?: string): { route: ClawMemResolvedRoute; conv: ConversationMirror; mem: MemoryStore; client: GitHubIssueClient } {
@@ -1706,11 +1775,30 @@ function shouldFallbackToAnonymousBootstrap(error: unknown): boolean {
 function toolText(text: string): { content: Array<{ type: "text"; text: string }> } {
   return { content: [{ type: "text", text }] };
 }
-function renderMemoryLine(memory: { memoryId: string; title?: string; detail: string; kind?: string; topics?: string[]; status: "active" | "stale" }): string {
-  const schema = [memory.kind ? `kind:${memory.kind}` : "", ...(memory.topics ?? []).map((topic) => `topic:${topic}`)].filter(Boolean).join(", ");
+function renderMemoryLine(memory: {
+  memoryId: string;
+  title?: string;
+  detail: string;
+  kind?: string;
+  topics?: string[];
+  status: "active" | "stale";
+}): string {
+  const schema = [
+    memory.kind ? `kind:${memory.kind}` : "",
+    ...(memory.topics ?? []).map((topic) => `topic:${topic}`),
+  ].filter(Boolean).join(", ");
   return `[${memory.memoryId}] ${memory.title || "Memory"}${schema ? ` (${schema})` : ""}${memory.status === "stale" ? " [stale]" : ""}: ${memory.detail}`;
 }
-function renderMemoryBlock(memory: { memoryId: string; issueNumber?: number; title?: string; detail: string; kind?: string; topics?: string[]; status: "active" | "stale"; date?: string }): string {
+function renderMemoryBlock(memory: {
+  memoryId: string;
+  issueNumber?: number;
+  title?: string;
+  detail: string;
+  kind?: string;
+  topics?: string[];
+  status: "active" | "stale";
+  date?: string;
+}): string {
   const lines = [
     `Memory ID: ${memory.memoryId}`,
     ...(typeof memory.issueNumber === "number" ? [`Issue Number: ${memory.issueNumber}`] : []),
@@ -1724,6 +1812,12 @@ function renderMemoryBlock(memory: { memoryId: string; issueNumber?: number; tit
   return lines.join("\n");
 }
 
+function formatInjectedMemory(memory: {
+  detail: string;
+}): string {
+  return memory.detail;
+}
+
 function renderOrgLine(org: { login?: string; name?: string; default_repository_permission?: string; description?: string }): string {
   const login = org.login?.trim() || "unknown-org";
   const name = org.name?.trim() ? ` (${org.name.trim()})` : "";

package/src/types.ts

@@ -15,6 +15,7 @@ export type ClawMemPluginConfig = {
   authScheme: "token" | "bearer";
   agents: Record<string, ClawMemAgentConfig>;
   memoryRecallLimit: number;
+  memoryAutoRecallLimit: number;
   turnCommentDelayMs: number;
   summaryWaitTimeoutMs: number;
 };