@clawmem-ai/clawmem 0.1.12 → 0.1.14

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 issue bodies store the durable detail plus flat metadata such as `memory_hash` and logical `date`; labels are reserved for schema and routing.
+- 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 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.12",
+  "version": "0.1.14",
   "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.12",
+  "version": "0.1.14",
   "description": "Mirror OpenClaw sessions into GitHub-compatible issues and comments.",
   "type": "module",
   "license": "MIT",

package/skills/clawmem/SKILL.md

@@ -46,8 +46,13 @@ 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.
+   - 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.
@@ -64,6 +69,11 @@ 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.
+- 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`.
 
 ## Read the right reference

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

@@ -27,6 +27,11 @@ 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
 
+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.
+
 Do not force English markers like `Memory hit` or `Locked memory` in non-English conversations. Those are examples, not required phrasing.
 
 Examples:

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

@@ -75,6 +75,11 @@ 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.
+
 ### With `gh`
 
 ```sh
@@ -85,8 +90,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 +110,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,14 @@ 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 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.
+
 ## 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();
 
@@ -168,12 +177,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({
@@ -211,7 +244,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 +276,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 +325,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"],
@@ -303,10 +336,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({
@@ -344,7 +419,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");
@@ -358,9 +433,11 @@ async function main(): Promise<void> {
   await testBackendSearchFallsBackToLocalLexical();
   testCjkScoring();
   await testStructuredStoreAndSchema();
+  await testStoreKeepsFullAutoTitleAndSupportsExplicitTitle();
   await testGetAndListMemories();
   await testLegacyMemoriesWithoutSessionOrDate();
   await testUpdateMemoryInPlace();
+  await testUpdateSupportsExplicitRetitle();
   await testForgetClosesMemoryIssue();
   console.log("memory tests passed");
 }