@clawmem-ai/clawmem 0.1.9 → 0.1.10

package/README.md

@@ -40,7 +40,7 @@ openclaw config validate
 openclaw gateway restart
 ```
 
-After restart, confirm OpenClaw shows ClawMem as the active memory plugin. clawmem then provisions per-agent memory repos on `git.clawmem.ai` as each agent is first used, then writes that agent's `token` + `repo` back into your config under `plugins.entries.clawmem.config.agents.<agentId>`. Memories start accumulating from that agent's next session.
+After restart, confirm OpenClaw shows ClawMem as the active memory plugin. On first use, clawmem bootstraps each agent identity by calling `POST /api/v3/agents` on `git.clawmem.ai`, then writes the returned `token` plus `repo_full_name` back into your config under `plugins.entries.clawmem.config.agents.<agentId>` as that agent's `defaultRepo`. Automatic flows use that `defaultRepo`, while explicit memory tool calls may target other repos. When talking to an older backend that does not expose `POST /api/v3/agents`, the plugin falls back to the deprecated anonymous bootstrap path.
 
 ---
 
@@ -274,21 +274,15 @@ Full config with all options:
           agents: {
             main: {
               baseUrl: "https://git.clawmem.ai/api/v3",
-              repo: "owner/main-memory",
+              defaultRepo: "owner/main-memory",
               token: "<token>",
               authScheme: "token"
             },
             coder: {
-              repo: "owner/coder-memory",
+              defaultRepo: "owner/coder-memory",
               token: "<token>"
             }
           },
-          issueTitlePrefix: "Session: ",
-          memoryTitlePrefix: "Memory: ",
-          defaultLabels: ["source:openclaw"],
-          agentLabelPrefix: "agent:",
-          autoCreateLabels: true,
-          closeIssueOnReset: true,
           turnCommentDelayMs: 1000,
           summaryWaitTimeoutMs: 120000,
           memoryRecallLimit: 5
@@ -308,8 +302,10 @@ Full config with all options:
 - 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.
 - 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_list`, `memory_get`, `memory_labels`, `memory_recall`, `memory_store`, `memory_update`, and `memory_forget` for mid-session use.
+- The plugin exposes `memory_repos`, `memory_repo_create`, `memory_list`, `memory_get`, `memory_labels`, `memory_recall`, `memory_store`, `memory_update`, and `memory_forget` for mid-session use.
+- Route resolution is now: agent identity supplies credentials, `defaultRepo` is the fallback memory space, and explicit tool calls may override repo per operation.
 - `memory_store` accepts optional schema hints such as kind and topics; the plugin normalizes them into managed `kind:*` and `topic:*` labels.
+- 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.

package/openclaw.plugin.json

@@ -1,18 +1,22 @@
 {
   "id": "clawmem",
   "name": "ClawMem",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "Mirror OpenClaw sessions into GitHub-compatible issues and comments.",
   "kind": "memory",
   "configSchema": {
     "type": "object",
-    "additionalProperties": false,
+    "additionalProperties": true,
     "properties": {
       "baseUrl": {
         "type": "string",
         "minLength": 1,
         "default": "https://git.clawmem.ai"
       },
+      "defaultRepo": {
+        "type": "string",
+        "pattern": "^[^/]+/[^/]+$"
+      },
       "repo": {
         "type": "string",
         "pattern": "^[^/]+/[^/]+$"
@@ -36,6 +40,10 @@
               "type": "string",
               "minLength": 1
             },
+            "defaultRepo": {
+              "type": "string",
+              "pattern": "^[^/]+/[^/]+$"
+            },
             "repo": {
               "type": "string",
               "pattern": "^[^/]+/[^/]+$"
@@ -51,40 +59,6 @@
           }
         }
       },
-      "issueTitlePrefix": {
-        "type": "string"
-      },
-      "memoryTitlePrefix": {
-        "type": "string"
-      },
-      "defaultLabels": {
-        "type": "array",
-        "items": {
-          "type": "string"
-        },
-        "default": ["source:openclaw"]
-      },
-      "agentLabelPrefix": {
-        "type": "string"
-      },
-      "activeStatusLabel": {
-        "type": "string"
-      },
-      "closedStatusLabel": {
-        "type": "string"
-      },
-      "memoryActiveStatusLabel": {
-        "type": "string"
-      },
-      "memoryStaleStatusLabel": {
-        "type": "string"
-      },
-      "autoCreateLabels": {
-        "type": "boolean"
-      },
-      "closeIssueOnReset": {
-        "type": "boolean"
-      },
       "turnCommentDelayMs": {
         "type": "integer",
         "minimum": 0,
@@ -99,15 +73,6 @@
         "type": "integer",
         "minimum": 1,
         "maximum": 20
-      },
-      "labelColor": {
-        "type": "string",
-        "pattern": "^#?[0-9a-fA-F]{6}$"
-      },
-      "maxExcerptChars": {
-        "type": "integer",
-        "minimum": 120,
-        "maximum": 4000
       }
     }
   },
@@ -117,10 +82,15 @@
       "placeholder": "https://git.clawmem.ai",
       "help": "GitHub-compatible API base URL. Root URLs are normalized to /api/v3 automatically."
     },
+    "defaultRepo": {
+      "label": "Default Repo",
+      "placeholder": "owner/repo",
+      "help": "Default memory repo for automatic flows and for tool calls that do not specify repo explicitly."
+    },
     "repo": {
       "label": "Repository",
       "placeholder": "owner/repo",
-      "help": "Legacy single-route setting. New installs should use per-agent routes under agents.<agentId>."
+      "help": "Legacy alias for defaultRepo. New installs should use defaultRepo or per-agent defaultRepo under agents.<agentId>."
     },
     "token": {
       "label": "API Token",
@@ -133,41 +103,7 @@
     },
     "agents": {
       "label": "Agent Routes",
-      "help": "Per-agent ClawMem credentials keyed by agent id. Missing repo/token are provisioned automatically on first use."
-    },
-    "defaultLabels": {
-      "label": "Default Labels",
-      "help": "Labels added to every new session issue. Good place for topic:* tags."
-    },
-    "memoryTitlePrefix": {
-      "label": "Memory Title Prefix",
-      "help": "Prefix used when creating memory issue titles."
-    },
-    "agentLabelPrefix": {
-      "label": "Agent Label Prefix",
-      "help": "Dynamic agent label prefix, for example agent:coder."
-    },
-    "activeStatusLabel": {
-      "label": "Active Status Label",
-      "help": "Deprecated compatibility setting. Conversation lifecycle now uses native issue state."
-    },
-    "closedStatusLabel": {
-      "label": "Closed Status Label",
-      "help": "Deprecated compatibility setting. Conversation lifecycle now uses native issue state."
-    },
-    "memoryActiveStatusLabel": {
-      "label": "Memory Active Status Label",
-      "help": "Deprecated compatibility setting. Memory lifecycle now uses native issue state."
-    },
-    "memoryStaleStatusLabel": {
-      "label": "Memory Stale Status Label",
-      "help": "Deprecated compatibility setting. Memory lifecycle now uses native issue state."
-    },
-    "autoCreateLabels": {
-      "label": "Auto Create Labels"
-    },
-    "closeIssueOnReset": {
-      "label": "Close On Reset"
+      "help": "Per-agent ClawMem identities keyed by agent id. Each identity has credentials plus an optional defaultRepo."
     },
     "turnCommentDelayMs": {
       "label": "Turn Sync Delay (ms)",
@@ -180,14 +116,6 @@
     "memoryRecallLimit": {
       "label": "Memory Recall Limit",
       "help": "Maximum number of active memories injected into context before an agent starts."
-    },
-    "labelColor": {
-      "label": "Fallback Label Color",
-      "placeholder": "0e8a16"
-    },
-    "maxExcerptChars": {
-      "label": "Max Excerpt Chars",
-      "help": "Soft cap used when rendering summaries and comment sections."
     }
   }
 }

package/package.json

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

package/src/config.test.ts

@@ -0,0 +1,82 @@
+import { hasDefaultRepo, isAgentConfigured, resolveAgentRoute } from "./config.js";
+import type { ClawMemPluginConfig } from "./types.js";
+import { buildAgentBootstrapRegistration, DEFAULT_BOOTSTRAP_REPO_NAME } from "./utils.js";
+
+function assert(condition: unknown, message: string): void {
+  if (!condition) throw new Error(message);
+}
+
+function baseConfig(): ClawMemPluginConfig {
+  return {
+    baseUrl: "https://git.clawmem.ai/api/v3",
+    authScheme: "token",
+    token: "top-token",
+    defaultRepo: "global/default-memory",
+    repo: "global/legacy-memory",
+    agents: {
+      main: {
+        token: "agent-token",
+        defaultRepo: "main/private-memory",
+      },
+      legacy: {
+        token: "legacy-token",
+        repo: "legacy/old-memory",
+      },
+      identityOnly: {
+        token: "identity-token",
+      },
+    },
+    memoryRecallLimit: 5,
+    turnCommentDelayMs: 1000,
+    summaryWaitTimeoutMs: 120000,
+  };
+}
+
+function testDefaultRepoResolution(): void {
+  const route = resolveAgentRoute(baseConfig(), "main");
+  assert(route.defaultRepo === "main/private-memory", "expected per-agent defaultRepo to be preferred");
+  assert(route.repo === "main/private-memory", "expected selected repo to default to defaultRepo");
+  assert(route.token === "agent-token", "expected per-agent token to be preferred");
+}
+
+function testRepoOverride(): void {
+  const route = resolveAgentRoute(baseConfig(), "main", "org/shared-memory");
+  assert(route.defaultRepo === "main/private-memory", "expected defaultRepo to remain unchanged");
+  assert(route.repo === "org/shared-memory", "expected explicit repo override to win");
+}
+
+function testLegacyRepoFallback(): void {
+  const route = resolveAgentRoute(baseConfig(), "legacy");
+  assert(route.defaultRepo === "legacy/old-memory", "expected legacy repo to act as defaultRepo fallback");
+  assert(route.repo === "legacy/old-memory", "expected selected repo to use the legacy repo fallback");
+}
+
+function testIdentityOnlyStillConfigured(): void {
+  const config = baseConfig();
+  delete config.defaultRepo;
+  delete config.repo;
+  const route = resolveAgentRoute(config, "identityOnly");
+  assert(isAgentConfigured(route) === true, "expected an identity with baseUrl and token to count as configured");
+  assert(hasDefaultRepo(route) === false, "expected no default repo when only credentials are present");
+}
+
+function testBootstrapRegistrationUsesStableDefaults(): void {
+  const registration = buildAgentBootstrapRegistration("Main_Coder");
+  assert(registration.prefixLogin === "main-coder", "expected agent bootstrap login prefix to match backend format");
+  assert(registration.defaultRepoName === DEFAULT_BOOTSTRAP_REPO_NAME, "expected bootstrap repo name to use the stable default");
+}
+
+function testBootstrapRegistrationTrimsLongPrefixes(): void {
+  const registration = buildAgentBootstrapRegistration("___THIS_IS_A_SUPER_LONG_AGENT_ID_THAT_SHOULD_BE_TRIMMED___");
+  assert(/^[a-z0-9][a-z0-9-]*$/.test(registration.prefixLogin), "expected bootstrap login prefix to satisfy backend validation");
+  assert(registration.prefixLogin.length <= 32, "expected bootstrap login prefix to fit backend max length");
+}
+
+testDefaultRepoResolution();
+testRepoOverride();
+testLegacyRepoFallback();
+testIdentityOnlyStillConfigured();
+testBootstrapRegistrationUsesStableDefaults();
+testBootstrapRegistrationTrimsLongPrefixes();
+
+console.log("config tests passed");

package/src/config.ts

@@ -5,7 +5,7 @@ import { normalizeAgentId } from "./utils.js";
 
 export const SESSION_TITLE_PREFIX = "Session: ";
 export const MEMORY_TITLE_PREFIX = "Memory: ";
-export const DEFAULT_LABELS: readonly string[] = ["source:openclaw"];
+export const DEFAULT_LABELS: readonly string[] = [];
 export const AGENT_LABEL_PREFIX = "agent:";
 export const LABEL_ACTIVE = "status:active";
 export const LABEL_CLOSED = "status:closed";
@@ -31,6 +31,7 @@ export function resolvePluginConfig(api: OpenClawPluginApi): ClawMemPluginConfig
     const agent = rawAgentConfig as Record<string, unknown>;
     agents[agentId] = {
       baseUrl: str(agent.baseUrl)?.replace(/\/+$/, ""),
+      defaultRepo: normalizeRepoName(str(agent.defaultRepo) ?? str(agent.repo)),
       repo: str(agent.repo),
       token: str(agent.token),
       authScheme: agent.authScheme === "bearer" ? "bearer" : agent.authScheme === "token" ? "token" : undefined,
@@ -38,6 +39,9 @@ export function resolvePluginConfig(api: OpenClawPluginApi): ClawMemPluginConfig
   }
   return {
     baseUrl: baseUrl.endsWith("/api/v3") ? baseUrl : `${baseUrl}/api/v3`,
+    defaultRepo: normalizeRepoName(str(raw.defaultRepo) ?? str(raw.repo)),
+    repo: normalizeRepoName(str(raw.repo)),
+    token: str(raw.token),
     authScheme: raw.authScheme === "bearer" ? "bearer" : "token",
     agents,
     memoryRecallLimit: clamp(num(raw.memoryRecallLimit, 5), 1, 20),
@@ -46,21 +50,28 @@ export function resolvePluginConfig(api: OpenClawPluginApi): ClawMemPluginConfig
   };
 }
 
-export function resolveAgentRoute(config: ClawMemPluginConfig, agentId?: string): ClawMemResolvedRoute {
+export function resolveAgentRoute(config: ClawMemPluginConfig, agentId?: string, repoOverride?: string): ClawMemResolvedRoute {
   const id = normalizeAgentId(agentId);
   const agent = config.agents[id] ?? {};
   const baseUrl = (agent.baseUrl ?? config.baseUrl).replace(/\/+$/, "");
+  const defaultRepo = normalizeRepoName(agent.defaultRepo ?? agent.repo) ?? config.defaultRepo ?? normalizeRepoName(config.repo);
+  const repo = normalizeRepoName(repoOverride) ?? defaultRepo;
   return {
     agentId: id,
     baseUrl: baseUrl.endsWith("/api/v3") ? baseUrl : `${baseUrl}/api/v3`,
-    repo: agent.repo?.trim() || undefined,
-    token: agent.token?.trim() || undefined,
-    authScheme: agent.authScheme === "bearer" ? "bearer" : config.authScheme,
+    ...(defaultRepo ? { defaultRepo } : {}),
+    ...(repo ? { repo } : {}),
+    token: agent.token?.trim() || config.token?.trim() || undefined,
+    authScheme: agent.authScheme === "bearer" ? "bearer" : agent.authScheme === "token" ? "token" : config.authScheme,
   };
 }
 
 export function isAgentConfigured(route: ClawMemResolvedRoute): boolean {
-  return Boolean(route.baseUrl && route.repo && route.token);
+  return Boolean(route.baseUrl && route.token);
+}
+
+export function hasDefaultRepo(route: ClawMemResolvedRoute): boolean {
+  return Boolean(route.defaultRepo);
 }
 
 export function resolveLabelColor(label: string): string {
@@ -97,3 +108,9 @@ export function labelVal(labels: string[], prefix: string): string | undefined {
   const m = labels.find((l) => l.startsWith(prefix));
   return m ? m.slice(prefix.length).trim() || undefined : undefined;
 }
+
+function normalizeRepoName(value: string | undefined): string | undefined {
+  if (!value) return undefined;
+  const trimmed = value.trim().replace(/^\/+|\/+$/g, "");
+  return /^[^/\s]+\/[^/\s]+$/.test(trimmed) ? trimmed : undefined;
+}

package/src/github-client.ts

@@ -1,11 +1,12 @@
 // GitHub Issues API client for clawmem. No label caching — idempotent create-if-absent.
 import { resolveLabelColor, labelDescription, extractLabelNames, isManagedLabel } from "./config.js";
-import type { AnonymousSessionResponse, ClawMemResolvedRoute } from "./types.js";
+import type { AgentRegistrationResponse, AnonymousSessionResponse, ClawMemResolvedRoute } from "./types.js";
 
 type IssueResponse = { number: number; title?: string; body?: string; state?: string; labels?: Array<{ name?: string } | string> };
 type SearchIssuesResponse = { items?: IssueResponse[]; total_count?: number; incomplete_results?: boolean };
 type CommentResponse = { id?: number; body?: string; created_at?: string };
 type LabelResponse = { name?: string; color?: string; description?: string };
+type RepoResponse = { name?: string; full_name?: string; description?: string; private?: boolean; owner?: { login?: string } };
 type ReqOpts = { allowNotFound?: boolean; allowValidationError?: boolean; omitAuth?: boolean };
 
 export class GitHubIssueClient {
@@ -14,6 +15,9 @@ export class GitHubIssueClient {
   repo(): string | undefined {
     return this.config.repo?.trim() || undefined;
   }
+  defaultRepo(): string | undefined {
+    return this.config.defaultRepo?.trim() || undefined;
+  }
 
   async createIssue(params: { title: string; body: string; labels: string[] }): Promise<IssueResponse> {
     return this.req<IssueResponse>(this.repoPath("issues"), { method: "POST", body: JSON.stringify(params) });
@@ -53,6 +57,20 @@ export class GitHubIssueClient {
     q.set("per_page", String(params?.perPage ?? 100));
     return this.req<LabelResponse[]>(`${this.repoPath("labels")}?${q}`, { method: "GET" });
   }
+  async listUserRepos(): Promise<RepoResponse[]> {
+    return this.req<RepoResponse[]>("user/repos", { method: "GET" });
+  }
+  async createUserRepo(params: { name: string; description?: string; private?: boolean; autoInit?: boolean }): Promise<RepoResponse> {
+    return this.req<RepoResponse>("user/repos", {
+      method: "POST",
+      body: JSON.stringify({
+        name: params.name,
+        ...(params.description ? { description: params.description } : {}),
+        private: params.private ?? true,
+        auto_init: params.autoInit ?? false,
+      }),
+    });
+  }
   async ensureLabels(labels: string[]): Promise<void> {
     for (const label of labels) {
       if (!label.trim()) continue;
@@ -71,6 +89,15 @@ export class GitHubIssueClient {
   async updateRepoDescription(description: string): Promise<void> {
     await this.req(this.repoPath("").replace(/\/$/, ""), { method: "PATCH", body: JSON.stringify({ description }) });
   }
+  async registerAgent(prefixLogin: string, defaultRepoName: string): Promise<AgentRegistrationResponse> {
+    return this.req<AgentRegistrationResponse>("agents", {
+      method: "POST",
+      body: JSON.stringify({
+        prefix_login: prefixLogin,
+        default_repo_name: defaultRepoName,
+      }),
+    }, { omitAuth: true });
+  }
   async createAnonymousSession(locale?: string): Promise<AnonymousSessionResponse> {
     const body = locale ? JSON.stringify({ locale }) : undefined;
     return this.req<AnonymousSessionResponse>("anonymous/session", { method: "POST", ...(body ? { body } : {}) }, { omitAuth: true });

package/src/memory.test.ts

@@ -7,7 +7,6 @@ function memory(overrides: Partial<ParsedMemoryIssue> = {}): ParsedMemoryIssue {
     issueNumber: overrides.issueNumber ?? 1,
     title: overrides.title ?? "Memory: Example",
     memoryId: overrides.memoryId ?? String(overrides.issueNumber ?? 1),
-    sessionId: overrides.sessionId ?? "sess-1",
     date: overrides.date ?? "2026-03-23",
     detail: overrides.detail ?? "Example durable detail",
     status: overrides.status ?? "active",
@@ -32,7 +31,6 @@ function issueFromMemory(m: ParsedMemoryIssue): IssueRecord {
     state: m.status === "stale" ? "closed" : "open",
     labels: [
       "type:memory",
-      `session:${m.sessionId}`,
       ...(m.kind ? [`kind:${m.kind}`] : []),
       ...(m.topics ?? []).map((topic) => `topic:${topic}`),
     ],
@@ -158,7 +156,7 @@ async function testStructuredStoreAndSchema(): Promise<void> {
     },
   };
   const store = new MemoryStore(client as never, {} as never, { memoryRecallLimit: 5, turnCommentDelayMs: 1000, summaryWaitTimeoutMs: 120000 } as never);
-  const result = await store.store({ detail: "Redis Lua scripts are required for atomic rate limiting.", kind: "Lesson", topics: ["Redis Ops", "rate_limit"] }, "manual");
+  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();
 
   assert(result.created === true, "expected a new structured memory to be created");
@@ -168,6 +166,7 @@ async function testStructuredStoreAndSchema(): Promise<void> {
   assert(created[0]?.labels.includes("kind:lesson"), "expected created labels to include normalized kind");
   assert(created[0]?.labels.includes("topic:redis-ops"), "expected created labels to include normalized topic");
   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(`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");
@@ -249,7 +248,6 @@ async function testLegacyMemoriesWithoutSessionOrDate(): Promise<void> {
   const recalled = await store.search("F1 Dota 2", 5);
 
   assert(exact?.issueNumber === 4, "expected legacy memory without session/date to be readable");
-  assert(exact?.sessionId === "legacy", "expected missing session label to fall back to legacy");
   assert(exact?.date === "1970-01-01", "expected missing date label to fall back to a placeholder");
   assert(recalled.some((memory) => memory.issueNumber === 4), "expected legacy memory to participate in recall");
 }

package/src/memory.ts

@@ -71,7 +71,7 @@ export class MemoryStore {
       .slice(0, limit);
   }
 
-  async store(draft: MemoryDraft, sessionId = "manual"): Promise<{ created: boolean; memory: ParsedMemoryIssue }> {
+  async store(draft: MemoryDraft): Promise<{ created: boolean; memory: ParsedMemoryIssue }> {
     const normalized = normalizeDraft(draft);
     const detail = norm(normalized.detail);
     const allActive = await this.listByStatus("active");
@@ -83,7 +83,7 @@ export class MemoryStore {
     }
 
     const date = localDate();
-    const labels = memLabels(sessionId, normalized.kind, normalized.topics);
+    const labels = memLabels(normalized.kind, normalized.topics);
     const title = `${MEMORY_TITLE_PREFIX}${trunc(detail, 72)}`;
     const body = stringifyFlatYaml([["memory_hash", hash], ["date", date], ["detail", detail]]);
     await this.client.ensureLabels(labels);
@@ -95,7 +95,6 @@ export class MemoryStore {
         title,
         memoryId: String(issue.number),
         memoryHash: hash,
-        sessionId,
         date,
         detail,
         ...(normalized.kind ? { kind: normalized.kind } : {}),
@@ -121,7 +120,7 @@ export class MemoryStore {
     if (duplicate) throw new Error(`another active memory already stores this detail as [${duplicate.memoryId}]`);
     const nextTitle = `${MEMORY_TITLE_PREFIX}${trunc(nextDetail, 72)}`;
     const nextBody = stringifyFlatYaml([["memory_hash", nextHash], ["date", current.date], ["detail", nextDetail]]);
-    const nextLabels = memLabels(current.sessionId, nextKind, nextTopics);
+    const nextLabels = memLabels(nextKind, nextTopics);
     await this.client.ensureLabels(nextLabels);
     await this.client.updateIssue(current.issueNumber, { title: nextTitle, body: nextBody });
     await this.client.syncManagedLabels(current.issueNumber, nextLabels);
@@ -140,7 +139,7 @@ export class MemoryStore {
     if (!id) throw new Error("memoryId is empty");
     const mem = await this.get(id, "active");
     if (!mem) return null;
-    await this.client.syncManagedLabels(mem.issueNumber, memLabels(mem.sessionId, mem.kind, mem.topics));
+    await this.client.syncManagedLabels(mem.issueNumber, memLabels(mem.kind, mem.topics));
     await this.client.updateIssue(mem.issueNumber, { state: "closed" });
     return { ...mem, status: "stale" };
   }
@@ -148,7 +147,7 @@ export class MemoryStore {
   async syncFromConversation(session: SessionMirrorState, snapshot: TranscriptSnapshot): Promise<boolean> {
     try {
       const decision = await this.generateDecision(session, snapshot);
-      const { savedCount, staledCount } = await this.applyDecision(session.sessionId, decision);
+      const { savedCount, staledCount } = await this.applyDecision(decision);
       if (savedCount > 0 || staledCount > 0)
         this.api.logger.info?.(`clawmem: synced memories for ${session.sessionId} (saved=${savedCount}, stale=${staledCount})`);
       return true;
@@ -199,7 +198,7 @@ export class MemoryStore {
   private parseIssue(issue: { number: number; title?: string; body?: string; state?: string; labels?: Array<{ name?: string } | string> }): ParsedMemoryIssue | null {
     const labels = extractLabelNames(issue.labels);
     if (!labels.includes("type:memory")) return null;
-    const sessionId = labelVal(labels, "session:"), kind = labelVal(labels, "kind:");
+    const kind = labelVal(labels, "kind:");
     const topics = labels.filter((l) => l.startsWith("topic:")).map((l) => l.slice(6).trim()).filter(Boolean);
     const rawBody = (issue.body ?? "").trim();
     const body = rawBody ? parseFlatYaml(rawBody) : {};
@@ -210,7 +209,6 @@ export class MemoryStore {
       issueNumber: issue.number, title: issue.title?.trim() || "",
       memoryId: body.memory_id?.trim() || String(issue.number),
       memoryHash: body.memory_hash?.trim() || undefined,
-      sessionId: sessionId || "legacy",
       date: body.date?.trim() || "1970-01-01",
       detail,
       ...(kind ? { kind } : {}),
@@ -219,7 +217,7 @@ export class MemoryStore {
     };
   }
 
-  private async applyDecision(sessionId: string, decision: MemoryDecision): Promise<{ savedCount: number; staledCount: number }> {
+  private async applyDecision(decision: MemoryDecision): Promise<{ savedCount: number; staledCount: number }> {
     const allActive = await this.listByStatus("active");
     const activeById = new Map(allActive.map((m) => [m.memoryId, m]));
     const activeByHash = new Map(allActive.map((m) => [m.memoryHash || sha256(norm(m.detail)), m]));
@@ -235,7 +233,7 @@ export class MemoryStore {
         activeByHash.set(hash, merged);
         continue;
       }
-      const labels = memLabels(sessionId, draft.kind, draft.topics);
+      const labels = memLabels(draft.kind, draft.topics);
       const date = localDate();
       const title = `${MEMORY_TITLE_PREFIX}${trunc(detail, 72)}`;
       const body = stringifyFlatYaml([["memory_hash", hash], ["date", date], ["detail", detail]]);
@@ -246,7 +244,6 @@ export class MemoryStore {
         title,
         memoryId: String(issue.number),
         memoryHash: hash,
-        sessionId,
         date,
         detail,
         ...(draft.kind ? { kind: draft.kind } : {}),
@@ -259,7 +256,7 @@ export class MemoryStore {
     for (const id of [...new Set(decision.stale.map((s) => s.trim()).filter(Boolean))]) {
       const mem = activeById.get(id);
       if (!mem) continue;
-      await this.client.syncManagedLabels(mem.issueNumber, memLabels(mem.sessionId, mem.kind, mem.topics));
+      await this.client.syncManagedLabels(mem.issueNumber, memLabels(mem.kind, mem.topics));
       await this.client.updateIssue(mem.issueNumber, { state: "closed" });
       staledCount++;
     }
@@ -318,7 +315,7 @@ export class MemoryStore {
     const sameKind = (memory.kind ?? "") === (nextKind ?? "");
     const sameTopics = JSON.stringify(currentTopics) === JSON.stringify(nextTopics);
     if (sameKind && sameTopics) return memory;
-    const labels = memLabels(memory.sessionId, nextKind, nextTopics);
+    const labels = memLabels(nextKind, nextTopics);
     await this.client.ensureLabels(labels);
     await this.client.syncManagedLabels(memory.issueNumber, labels);
     return {
@@ -329,10 +326,9 @@ export class MemoryStore {
   }
 }
 
-function memLabels(sessionId: string, kind?: string, topics?: string[]): string[] {
+function memLabels(kind?: string, topics?: string[]): string[] {
   return [
     "type:memory",
-    `session:${sessionId}`,
     ...(kind ? [`kind:${kind}`] : []),
     ...((topics ?? []).map((topic) => `topic:${topic}`)),
   ];

package/src/service.ts

@@ -1,14 +1,14 @@
 // Thin orchestrator: wires conversation mirroring, memory store, and plugin lifecycle.
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
-import { isAgentConfigured, resolveAgentRoute, resolvePluginConfig } from "./config.js";
+import { hasDefaultRepo, isAgentConfigured, resolveAgentRoute, resolvePluginConfig } from "./config.js";
 import { ConversationMirror } from "./conversation.js";
 import { GitHubIssueClient } from "./github-client.js";
 import { KeyedAsyncQueue } from "./keyed-async-queue.js";
 import { MemoryStore } from "./memory.js";
 import { loadState, resolveStatePath, saveState } from "./state.js";
 import { readTranscriptSnapshot } from "./transcript.js";
-import type { ClawMemPluginConfig, PluginState, SessionMirrorState, TranscriptSnapshot } from "./types.js";
-import { inferAgentIdFromTranscriptPath, normalizeAgentId, sessionScopeKey } from "./utils.js";
+import type { BootstrapIdentityResponse, ClawMemPluginConfig, ClawMemResolvedRoute, PluginState, SessionMirrorState, TranscriptSnapshot } from "./types.js";
+import { buildAgentBootstrapRegistration, inferAgentIdFromTranscriptPath, normalizeAgentId, sessionScopeKey } from "./utils.js";
 
 type TurnPayload = { sessionId?: string; sessionKey?: string; agentId?: string; messages: unknown[] };
 type FinalizePayload = { sessionId?: string; sessionKey?: string; sessionFile?: string; agentId?: string; reason?: string; messages?: unknown[] };
@@ -46,7 +46,8 @@ class ClawMemService {
           void this.track(this.handleTranscript(u.sessionFile)).catch((e) => this.warn("transcript update", e));
         });
         const configuredCount = Object.keys(this.config.agents).filter((agentId) => {
-          return isAgentConfigured(resolveAgentRoute(this.config, agentId));
+          const route = resolveAgentRoute(this.config, agentId);
+          return isAgentConfigured(route) && hasDefaultRepo(route);
         }).length;
         this.api.logger.info?.(
           configuredCount > 0
@@ -64,6 +65,86 @@ class ClawMemService {
   }
 
   private registerTools(): void {
+    this.api.registerTool({
+      name: "memory_repos",
+      description: "List the memory repos the current ClawMem agent identity can access so the agent can choose the right space before retrieving or storing memory.",
+      required: true,
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          agentId: { type: "string", minLength: 1, description: "Optional agent identity override. Defaults to the current agent when available." },
+        },
+      },
+      execute: async (_id: string, params: unknown) => {
+        const p = asRecord(params);
+        const agentId = this.resolveToolAgentId(p.agentId);
+        const resolved = await this.requireToolIdentity(agentId);
+        if ("error" in resolved) return toolText(resolved.error);
+        const repos = await resolved.client.listUserRepos();
+        if (repos.length === 0) return toolText(`Agent "${agentId}" has no accessible ClawMem repos yet.`);
+        const lines = [
+          `Accessible ClawMem repos for agent "${agentId}":`,
+          ...repos
+            .map((repo) => {
+              const fullName = repo.full_name?.trim() || repo.name?.trim() || "unknown";
+              const flags = [
+                resolved.route.defaultRepo === fullName ? "default" : "",
+                repo.private ? "private" : "shared",
+              ].filter(Boolean).join(", ");
+              const description = repo.description?.trim() ? ` - ${repo.description.trim()}` : "";
+              return `- ${fullName}${flags ? ` [${flags}]` : ""}${description}`;
+            }),
+        ];
+        return toolText(lines.join("\n"));
+      },
+    });
+
+    this.api.registerTool({
+      name: "memory_repo_create",
+      description: "Create a new ClawMem repo under the current agent identity when the agent decides a new memory space is needed.",
+      required: true,
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          name: { type: "string", minLength: 1, description: "Repository name only, without owner prefix." },
+          description: { type: "string", minLength: 1, description: "Optional repo description." },
+          private: { type: "boolean", description: "Whether the new repo should be private. Defaults to true." },
+          setDefault: { type: "boolean", description: "Whether to make the new repo this agent's default memory repo." },
+          agentId: { type: "string", minLength: 1, description: "Optional agent identity override. Defaults to the current agent when available." },
+        },
+        required: ["name"],
+      },
+      execute: async (_id: string, params: unknown) => {
+        const p = asRecord(params);
+        const name = typeof p.name === "string" ? p.name.trim() : "";
+        if (!name) return toolText("name is empty.");
+        const agentId = this.resolveToolAgentId(p.agentId);
+        const resolved = await this.requireToolIdentity(agentId);
+        if ("error" in resolved) return toolText(resolved.error);
+        const created = await resolved.client.createUserRepo({
+          name,
+          ...(typeof p.description === "string" && p.description.trim() ? { description: p.description.trim() } : {}),
+          ...(typeof p.private === "boolean" ? { private: p.private } : {}),
+        });
+        const fullName = created.full_name?.trim() || created.name?.trim() || name;
+        let defaultNote = "";
+        const shouldSetDefault = p.setDefault === true || !resolved.route.defaultRepo;
+        if (shouldSetDefault && fullName.includes("/")) {
+          await this.persistAgentConfig(agentId, {
+            baseUrl: resolved.route.baseUrl,
+            authScheme: resolved.route.authScheme,
+            token: resolved.route.token!,
+            defaultRepo: fullName,
+          });
+          this.config.agents[agentId] = { ...(this.config.agents[agentId] ?? {}), defaultRepo: fullName };
+          defaultNote = resolved.route.defaultRepo ? "\nSet as default repo for this agent." : "\nSet as the first default repo for this agent.";
+        }
+        return toolText(`Created memory repo ${fullName}.${defaultNote}`);
+      },
+    });
+
     this.api.registerTool({
       name: "memory_list",
       description: "List ClawMem memories by status or schema so the agent can inspect the current memory index before deduping or saving.",
@@ -76,25 +157,26 @@ class ClawMemService {
           kind: { type: "string", minLength: 1, description: "Optional kind filter, for example core-fact, lesson, or task." },
           topic: { type: "string", minLength: 1, description: "Optional topic filter." },
           limit: { type: "integer", minimum: 1, maximum: 200, description: "Maximum number of memories to return." },
+          repo: { type: "string", minLength: 3, description: "Optional memory repo override in owner/repo form. Defaults to the agent's defaultRepo." },
           agentId: { type: "string", minLength: 1, description: "Optional agent route override. Defaults to the current agent when available." },
         },
       },
       execute: async (_id: string, params: unknown) => {
         const p = asRecord(params);
         const agentId = this.resolveToolAgentId(p.agentId);
-        if (!(await this.ensureConfigured(agentId))) return toolText(`ClawMem route for agent "${agentId}" is not configured.`);
-        const { mem } = this.getServices(agentId);
+        const resolved = await this.requireToolRoute(agentId, p.repo);
+        if ("error" in resolved) return toolText(resolved.error);
         const status = p.status === "stale" || p.status === "all" ? p.status : "active";
         const limit = typeof p.limit === "number" && Number.isFinite(p.limit) ? Math.floor(p.limit) : 20;
         const kind = typeof p.kind === "string" && p.kind.trim() ? p.kind.trim() : undefined;
         const topic = typeof p.topic === "string" && p.topic.trim() ? p.topic.trim() : undefined;
-        const memories = await mem.listMemories({ status, kind, topic, limit });
+        const memories = await resolved.mem.listMemories({ status, kind, topic, limit });
         if (memories.length === 0) {
           const filters = [status !== "active" ? `status=${status}` : "", kind ? `kind=${kind}` : "", topic ? `topic=${topic}` : ""].filter(Boolean).join(", ");
-          return toolText(`No memories matched${filters ? ` (${filters})` : ""}.`);
+          return toolText(`No memories matched in ${resolved.route.repo}${filters ? ` (${filters})` : ""}.`);
         }
         const lines = [
-          `Found ${memories.length} ${status === "all" ? "" : `${status} `}memor${memories.length === 1 ? "y" : "ies"}:`,
+          `Found ${memories.length} ${status === "all" ? "" : `${status} `}memor${memories.length === 1 ? "y" : "ies"} in ${resolved.route.repo}:`,
           ...memories.map((memory) => `- ${renderMemoryLine(memory)}`),
         ];
         return toolText(lines.join("\n"));
@@ -109,6 +191,7 @@ class ClawMemService {
         type: "object",
         additionalProperties: false,
         properties: {
+          repo: { type: "string", minLength: 3, description: "Optional memory repo override in owner/repo form. Defaults to the agent's defaultRepo." },
           agentId: { type: "string", minLength: 1, description: "Optional agent route override. Defaults to the current agent when available." },
           limitTopics: { type: "integer", minimum: 1, maximum: 200, description: "Maximum number of topic labels to display." },
         },
@@ -116,16 +199,16 @@ class ClawMemService {
       execute: async (_id: string, params: unknown) => {
         const p = asRecord(params);
         const agentId = this.resolveToolAgentId(p.agentId);
-        if (!(await this.ensureConfigured(agentId))) return toolText(`ClawMem route for agent "${agentId}" is not configured.`);
-        const { mem } = this.getServices(agentId);
-        const schema = await mem.listSchema();
+        const resolved = await this.requireToolRoute(agentId, p.repo);
+        if ("error" in resolved) return toolText(resolved.error);
+        const schema = await resolved.mem.listSchema();
         const rawLimit = typeof p.limitTopics === "number" && Number.isFinite(p.limitTopics) ? Math.floor(p.limitTopics) : 50;
         const limitTopics = Math.min(200, Math.max(1, rawLimit));
         const kinds = schema.kinds.length > 0 ? schema.kinds.map((kind) => `- kind:${kind}`).join("\n") : "- None";
         const topics = schema.topics.length > 0 ? schema.topics.slice(0, limitTopics).map((topic) => `- topic:${topic}`).join("\n") : "- None";
         const extra = schema.topics.length > limitTopics ? `\n- ...and ${schema.topics.length - limitTopics} more topics` : "";
         return toolText([
-          "Current ClawMem schema labels:",
+          `Current ClawMem schema labels in ${resolved.route.repo}:`,
           "",
           "Kinds:",
           kinds,
@@ -146,6 +229,7 @@ class ClawMemService {
         properties: {
           query: { type: "string", minLength: 1, description: "What to recall from memory." },
           limit: { type: "integer", minimum: 1, maximum: 20, description: "Maximum number of memories to return." },
+          repo: { type: "string", minLength: 3, description: "Optional memory repo override in owner/repo form. Defaults to the agent's defaultRepo." },
           agentId: { type: "string", minLength: 1, description: "Optional agent route override. Defaults to the current agent when available." },
         },
         required: ["query"],
@@ -155,14 +239,14 @@ class ClawMemService {
         const query = typeof p.query === "string" ? p.query.trim() : "";
         if (!query) return toolText("Query is empty.");
         const agentId = this.resolveToolAgentId(p.agentId);
-        if (!(await this.ensureConfigured(agentId))) return toolText(`ClawMem route for agent "${agentId}" is not configured.`);
-        const { mem } = this.getServices(agentId);
+        const resolved = await this.requireToolRoute(agentId, p.repo);
+        if ("error" in resolved) return toolText(resolved.error);
         const rawLimit = typeof p.limit === "number" && Number.isFinite(p.limit) ? Math.floor(p.limit) : this.config.memoryRecallLimit;
         const limit = Math.min(20, Math.max(1, rawLimit));
-        const memories = await mem.search(query, limit);
-        if (memories.length === 0) return toolText(`No active memories matched "${query}".`);
+        const memories = await resolved.mem.search(query, limit);
+        if (memories.length === 0) return toolText(`No active memories matched "${query}" in ${resolved.route.repo}.`);
         const text = [
-          `Found ${memories.length} active memor${memories.length === 1 ? "y" : "ies"} for "${query}":`,
+          `Found ${memories.length} active memor${memories.length === 1 ? "y" : "ies"} for "${query}" in ${resolved.route.repo}:`,
           ...memories.map((memory) => `- ${renderMemoryLine(memory)}`),
         ].join("\n");
         return toolText(text);
@@ -179,6 +263,7 @@ class ClawMemService {
         properties: {
           memoryId: { type: "string", minLength: 1, description: "The memory id or issue number to retrieve." },
           status: { type: "string", enum: ["active", "stale", "all"], description: "Which status bucket to search. Defaults to all." },
+          repo: { type: "string", minLength: 3, description: "Optional memory repo override in owner/repo form. Defaults to the agent's defaultRepo." },
           agentId: { type: "string", minLength: 1, description: "Optional agent route override. Defaults to the current agent when available." },
         },
         required: ["memoryId"],
@@ -188,12 +273,12 @@ class ClawMemService {
         const memoryId = typeof p.memoryId === "string" ? p.memoryId.trim() : "";
         if (!memoryId) return toolText("memoryId is empty.");
         const agentId = this.resolveToolAgentId(p.agentId);
-        if (!(await this.ensureConfigured(agentId))) return toolText(`ClawMem route for agent "${agentId}" is not configured.`);
-        const { mem } = this.getServices(agentId);
+        const resolved = await this.requireToolRoute(agentId, p.repo);
+        if ("error" in resolved) return toolText(resolved.error);
         const status = p.status === "active" || p.status === "stale" ? p.status : "all";
-        const memory = await mem.get(memoryId, status);
-        if (!memory) return toolText(`No ${status === "all" ? "" : `${status} `}memory matched id "${memoryId}".`);
-        return toolText(renderMemoryBlock(memory));
+        const memory = await resolved.mem.get(memoryId, status);
+        if (!memory) return toolText(`No ${status === "all" ? "" : `${status} `}memory matched id "${memoryId}" in ${resolved.route.repo}.`);
+        return toolText(`Repo: ${resolved.route.repo}\n${renderMemoryBlock(memory)}`);
       },
     });
 
@@ -214,7 +299,7 @@ class ClawMemService {
             minItems: 1,
             maxItems: 10,
           },
-          sessionId: { type: "string", minLength: 1, description: "Optional source session id label. Defaults to manual." },
+          repo: { type: "string", minLength: 3, description: "Optional memory repo override in owner/repo form. Defaults to the agent's defaultRepo." },
           agentId: { type: "string", minLength: 1, description: "Optional agent route override. Defaults to the current agent when available." },
         },
         required: ["detail"],
@@ -224,14 +309,13 @@ class ClawMemService {
         const detail = typeof p.detail === "string" ? p.detail.trim() : "";
         if (!detail) return toolText("Detail is empty.");
         const agentId = this.resolveToolAgentId(p.agentId);
-        if (!(await this.ensureConfigured(agentId))) return toolText(`ClawMem route for agent "${agentId}" is not configured.`);
-        const { mem } = this.getServices(agentId);
-        const sessionId = typeof p.sessionId === "string" && p.sessionId.trim() ? p.sessionId.trim() : "manual";
+        const resolved = await this.requireToolRoute(agentId, p.repo);
+        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 mem.store({ detail, ...(kind ? { kind } : {}), ...(topics && topics.length > 0 ? { topics } : {}) }, sessionId);
-        if (!result.created) return toolText(`Memory already exists.\n${renderMemoryBlock(result.memory)}`);
-        return toolText(`Stored memory.\n${renderMemoryBlock(result.memory)}`);
+        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)}`);
       },
     });
 
@@ -253,6 +337,7 @@ class ClawMemService {
             minItems: 1,
             maxItems: 10,
           },
+          repo: { type: "string", minLength: 3, description: "Optional memory repo override in owner/repo form. Defaults to the agent's defaultRepo." },
           agentId: { type: "string", minLength: 1, description: "Optional agent route override. Defaults to the current agent when available." },
         },
         required: ["memoryId"],
@@ -266,16 +351,16 @@ class ClawMemService {
         const topics = Array.isArray(p.topics) ? p.topics.filter((topic): topic is string => typeof topic === "string" && topic.trim().length > 0) : undefined;
         if (!detail && kind === undefined && topics === undefined) return toolText("Provide at least one of detail, kind, or topics.");
         const agentId = this.resolveToolAgentId(p.agentId);
-        if (!(await this.ensureConfigured(agentId))) return toolText(`ClawMem route for agent "${agentId}" is not configured.`);
-        const { mem } = this.getServices(agentId);
+        const resolved = await this.requireToolRoute(agentId, p.repo);
+        if ("error" in resolved) return toolText(resolved.error);
         let updated;
         try {
-          updated = await mem.update(memoryId, { ...(detail ? { detail } : {}), ...(kind !== undefined ? { kind } : {}), ...(topics !== undefined ? { topics } : {}) });
+          updated = await resolved.mem.update(memoryId, { ...(detail ? { detail } : {}), ...(kind !== undefined ? { kind } : {}), ...(topics !== undefined ? { topics } : {}) });
         } catch (error) {
           return toolText(`Unable to update memory "${memoryId}": ${String(error)}`);
         }
-        if (!updated) return toolText(`No memory matched id "${memoryId}".`);
-        return toolText(`Updated memory.\n${renderMemoryBlock(updated)}`);
+        if (!updated) return toolText(`No memory matched id "${memoryId}" in ${resolved.route.repo}.`);
+        return toolText(`Updated memory in ${resolved.route.repo}.\n${renderMemoryBlock(updated)}`);
       },
     });
 
@@ -288,6 +373,7 @@ class ClawMemService {
         additionalProperties: false,
         properties: {
           memoryId: { type: "string", minLength: 1, description: "The memory id or issue number to mark stale." },
+          repo: { type: "string", minLength: 3, description: "Optional memory repo override in owner/repo form. Defaults to the agent's defaultRepo." },
           agentId: { type: "string", minLength: 1, description: "Optional agent route override. Defaults to the current agent when available." },
         },
         required: ["memoryId"],
@@ -297,18 +383,18 @@ class ClawMemService {
         const memoryId = typeof p.memoryId === "string" ? p.memoryId.trim() : "";
         if (!memoryId) return toolText("memoryId is empty.");
         const agentId = this.resolveToolAgentId(p.agentId);
-        if (!(await this.ensureConfigured(agentId))) return toolText(`ClawMem route for agent "${agentId}" is not configured.`);
-        const { mem } = this.getServices(agentId);
-        const forgotten = await mem.forget(memoryId);
-        if (!forgotten) return toolText(`No active memory matched id "${memoryId}".`);
-        return toolText(`Marked memory [${forgotten.memoryId}] stale: ${forgotten.detail}`);
+        const resolved = await this.requireToolRoute(agentId, p.repo);
+        if ("error" in resolved) return toolText(resolved.error);
+        const forgotten = await resolved.mem.forget(memoryId);
+        if (!forgotten) return toolText(`No active memory matched id "${memoryId}" in ${resolved.route.repo}.`);
+        return toolText(`Marked memory [${forgotten.memoryId}] stale in ${resolved.route.repo}: ${forgotten.detail}`);
       },
     });
   }
 
   private async handleBeforeAgentStart(prompt: unknown, agentId?: string): Promise<{ prependContext: string } | void> {
     const routeAgentId = normalizeAgentId(agentId);
-    if (!(await this.ensureConfigured(routeAgentId))) return;
+    if (!(await this.ensureDefaultRepoConfigured(routeAgentId))) return;
     await this.runRequestMaintenance(routeAgentId);
     if (typeof prompt !== "string" || prompt.trim().length < 5) return;
     try {
@@ -333,7 +419,7 @@ class ClawMemService {
     }
     const { conv } = this.getServices(agentId);
     if (!conv.shouldMirror(snap.sessionId, snap.messages)) return;
-    if (!(await this.ensureConfigured(agentId))) return;
+    if (!(await this.ensureDefaultRepoConfigured(agentId))) return;
     await this.enqueueSession(sessionScopeKey(snap.sessionId, agentId), async () => {
       const s = this.getOrCreate(snap.sessionId!, agentId);
       s.sessionFile = sessionFile;
@@ -359,7 +445,7 @@ class ClawMemService {
   private async syncTurn(p: TurnPayload): Promise<void> {
     if (!p.sessionId) return;
     const agentId = normalizeAgentId(p.agentId);
-    if (!(await this.ensureConfigured(agentId))) return;
+    if (!(await this.ensureDefaultRepoConfigured(agentId))) return;
     const { conv } = this.getServices(agentId);
     const s = this.getOrCreate(p.sessionId, agentId);
     s.sessionKey = p.sessionKey ?? s.sessionKey; s.agentId = agentId; s.updatedAt = new Date().toISOString();
@@ -383,7 +469,7 @@ class ClawMemService {
   private async finalize(p: FinalizePayload): Promise<void> {
     if (!p.sessionId) return;
     const agentId = normalizeAgentId(p.agentId);
-    if (!(await this.ensureConfigured(agentId))) return;
+    if (!(await this.ensureDefaultRepoConfigured(agentId))) return;
     const { conv } = this.getServices(agentId);
     const s = this.getOrCreate(p.sessionId, agentId);
     if (s.finalizedAt) return;
@@ -456,7 +542,7 @@ class ClawMemService {
     })();
     return this.loadPromise;
   }
-  private async ensureConfigured(agentId?: string): Promise<boolean> {
+  private async ensureIdentityConfigured(agentId?: string): Promise<boolean> {
     const id = normalizeAgentId(agentId);
     if (isAgentConfigured(resolveAgentRoute(this.config, id))) return true;
     const pending = this.configPromises.get(id);
@@ -465,19 +551,50 @@ class ClawMemService {
     this.configPromises.set(id, p);
     try { return await p; } finally { if (this.configPromises.get(id) === p) this.configPromises.delete(id); }
   }
+  private async ensureDefaultRepoConfigured(agentId?: string): Promise<boolean> {
+    const id = normalizeAgentId(agentId);
+    if (!(await this.ensureIdentityConfigured(id))) return false;
+    return hasDefaultRepo(resolveAgentRoute(this.config, id));
+  }
   private async bootstrap(agentId: string): Promise<boolean> {
     const route = resolveAgentRoute(this.config, agentId);
     if (!route.baseUrl) { this.api.logger.warn(`clawmem: cannot provision Git credentials for ${agentId} without a baseUrl`); return false; }
     try {
       const client = new GitHubIssueClient(route, this.api.logger);
-      const locale = Intl?.DateTimeFormat?.()?.resolvedOptions?.()?.locale ?? "";
-      const sess = await client.createAnonymousSession(locale);
-      await this.persistAgentConfig(agentId, { baseUrl: route.baseUrl, authScheme: "token", token: sess.token, repo: sess.repo_full_name });
-      this.config.agents[agentId] = { ...(this.config.agents[agentId] ?? {}), baseUrl: route.baseUrl, authScheme: "token", token: sess.token, repo: sess.repo_full_name };
-      this.api.logger.info?.(`clawmem: provisioned Git credentials for agent ${agentId} -> ${sess.repo_full_name} via ${route.baseUrl}`);
+      const bootstrap = await this.provisionAgentIdentity(client, agentId);
+      await this.persistAgentConfig(agentId, {
+        baseUrl: route.baseUrl,
+        authScheme: "token",
+        token: bootstrap.identity.token,
+        defaultRepo: bootstrap.identity.repo_full_name,
+      });
+      this.config.agents[agentId] = {
+        ...(this.config.agents[agentId] ?? {}),
+        baseUrl: route.baseUrl,
+        authScheme: "token",
+        token: bootstrap.identity.token,
+        defaultRepo: bootstrap.identity.repo_full_name,
+      };
+      this.api.logger.info?.(
+        `clawmem: provisioned Git credentials for agent ${agentId} with default repo ${bootstrap.identity.repo_full_name} via ${route.baseUrl} (${bootstrap.method})`,
+      );
       return true;
     } catch (error) { this.api.logger.warn(`clawmem: failed to provision Git credentials for agent ${agentId} via ${route.baseUrl}: ${String(error)}`); return false; }
   }
+  private async provisionAgentIdentity(client: GitHubIssueClient, agentId: string): Promise<{ identity: BootstrapIdentityResponse; method: string }> {
+    const registration = buildAgentBootstrapRegistration(agentId);
+    try {
+      const identity = await client.registerAgent(registration.prefixLogin, registration.defaultRepoName);
+      return { identity, method: "/api/v3/agents" };
+    } catch (error) {
+      if (!shouldFallbackToAnonymousBootstrap(error)) throw error;
+      this.api.logger.warn?.(`clawmem: /api/v3/agents is unavailable for agent ${agentId}; falling back to deprecated anonymous bootstrap`);
+    }
+
+    const locale = Intl?.DateTimeFormat?.()?.resolvedOptions?.()?.locale ?? "";
+    const identity = await client.createAnonymousSession(locale);
+    return { identity, method: "/api/v3/anonymous/session" };
+  }
   private warnIfInactiveMemorySlot(): void {
     try {
       const root = this.api.runtime.config.loadConfig();
@@ -499,7 +616,7 @@ class ClawMemService {
       this.api.logger.warn(`clawmem: memory slot check failed: ${String(error)}`);
     }
   }
-  private async persistAgentConfig(agentId: string, values: { baseUrl: string; authScheme: "token" | "bearer"; token: string; repo: string }): Promise<void> {
+  private async persistAgentConfig(agentId: string, values: { baseUrl: string; authScheme: "token" | "bearer"; token: string; defaultRepo: string }): Promise<void> {
     const root = this.api.runtime.config.loadConfig();
     const plugins = root.plugins;
     const entries = plugins?.entries && typeof plugins.entries === "object" && !Array.isArray(plugins.entries) ? (plugins.entries as Record<string, unknown>) : {};
@@ -577,9 +694,12 @@ class ClawMemService {
     if (changed) await this.persistState();
   }
 
-  private getServices(agentId?: string): { conv: ConversationMirror; mem: MemoryStore } {
-    const client = new GitHubIssueClient(resolveAgentRoute(this.config, agentId), this.api.logger);
+  private getServices(agentId?: string, repo?: string): { route: ClawMemResolvedRoute; conv: ConversationMirror; mem: MemoryStore; client: GitHubIssueClient } {
+    const route = resolveAgentRoute(this.config, agentId, repo);
+    const client = new GitHubIssueClient(route, this.api.logger);
     return {
+      route,
+      client,
       conv: new ConversationMirror(client, this.api, this.config),
       mem: new MemoryStore(client, this.api, this.config),
     };
@@ -587,6 +707,34 @@ class ClawMemService {
   private resolveToolAgentId(agentId: unknown): string {
     return normalizeAgentId(typeof agentId === "string" && agentId.trim() ? agentId : process.env.OPENCLAW_AGENT_ID);
   }
+  private resolveToolRepo(repo: unknown): { repo?: string; error?: string } {
+    if (repo === undefined || repo === null || repo === "") return {};
+    if (typeof repo !== "string") return { error: "repo must be a string like owner/repo." };
+    const trimmed = repo.trim().replace(/^\/+|\/+$/g, "");
+    if (!/^[^/\s]+\/[^/\s]+$/.test(trimmed)) return { error: `Invalid repo "${repo}". Expected owner/repo.` };
+    return { repo: trimmed };
+  }
+  private async requireToolIdentity(agentId: string): Promise<{ route: ClawMemResolvedRoute; client: GitHubIssueClient } | { error: string }> {
+    if (!(await this.ensureIdentityConfigured(agentId))) {
+      return { error: `ClawMem identity for agent "${agentId}" is not configured.` };
+    }
+    const { route, client } = this.getServices(agentId);
+    return { route, client };
+  }
+  private async requireToolRoute(agentId: string, repo: unknown): Promise<{ route: ClawMemResolvedRoute; conv: ConversationMirror; mem: MemoryStore; client: GitHubIssueClient } | { error: string }> {
+    const parsed = this.resolveToolRepo(repo);
+    if (parsed.error) return { error: parsed.error };
+    if (!(await this.ensureIdentityConfigured(agentId))) {
+      return { error: `ClawMem identity for agent "${agentId}" is not configured.` };
+    }
+    const services = this.getServices(agentId, parsed.repo);
+    if (!services.route.repo) {
+      return {
+        error: `No memory repo selected for agent "${agentId}". Provide repo explicitly or configure agents.${agentId}.defaultRepo.`,
+      };
+    }
+    return services;
+  }
   /**
    * After finalization, check if the repo still has an empty/default description.
    * If so, use the conversation summary to suggest a meaningful name and update
@@ -613,6 +761,10 @@ class ClawMemService {
 }
 
 function asRecord(v: unknown): Record<string, unknown> { return v && typeof v === "object" ? (v as Record<string, unknown>) : {}; }
+function shouldFallbackToAnonymousBootstrap(error: unknown): boolean {
+  const msg = String(error);
+  return /^Error:\s*HTTP (404|405|501):/i.test(msg) || /^HTTP (404|405|501):/i.test(msg);
+}
 function toolText(text: string): { content: Array<{ type: "text"; text: string }> } {
   return { content: [{ type: "text", text }] };
 }
@@ -620,7 +772,7 @@ function renderMemoryLine(memory: { memoryId: string; title?: string; detail: st
   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"; sessionId?: string; 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}`] : []),
@@ -628,7 +780,6 @@ function renderMemoryBlock(memory: { memoryId: string; issueNumber?: number; tit
     `Title: ${memory.title || "Memory"}`,
     ...(memory.kind ? [`Kind: ${memory.kind}`] : []),
     ...(memory.topics && memory.topics.length > 0 ? [`Topics: ${memory.topics.join(", ")}`] : []),
-    ...(memory.sessionId ? [`Session: ${memory.sessionId}`] : []),
     ...(memory.date ? [`Date: ${memory.date}`] : []),
     `Detail: ${memory.detail}`,
   ];

package/src/types.ts

@@ -1,6 +1,7 @@
 // Shared types for the clawmem plugin.
 export type ClawMemAgentConfig = {
   baseUrl?: string;
+  defaultRepo?: string;
   repo?: string;
   token?: string;
   authScheme?: "token" | "bearer";
@@ -8,6 +9,9 @@ export type ClawMemAgentConfig = {
 
 export type ClawMemPluginConfig = {
   baseUrl: string;
+  defaultRepo?: string;
+  repo?: string;
+  token?: string;
   authScheme: "token" | "bearer";
   agents: Record<string, ClawMemAgentConfig>;
   memoryRecallLimit: number;
@@ -18,12 +22,15 @@ export type ClawMemPluginConfig = {
 export type ClawMemResolvedRoute = {
   agentId: string;
   baseUrl: string;
+  defaultRepo?: string;
   repo?: string;
   token?: string;
   authScheme: "token" | "bearer";
 };
 
-export type AnonymousSessionResponse = { token: string; owner_login: string; repo_name: string; repo_full_name: string };
+export type BootstrapIdentityResponse = { token: string; repo_full_name: string };
+export type AgentRegistrationResponse = BootstrapIdentityResponse & { login: string };
+export type AnonymousSessionResponse = BootstrapIdentityResponse & { owner_login: string; repo_name: string };
 export type SessionMirrorState = {
   sessionId: string; sessionKey?: string; sessionFile?: string; agentId?: string;
   issueNumber?: number; issueTitle?: string; titleSource?: "placeholder" | "llm";
@@ -46,6 +53,6 @@ export type MemoryListOptions = {
 };
 export type ParsedMemoryIssue = {
   issueNumber: number; title: string; memoryId: string; memoryHash?: string;
-  sessionId: string; date: string; detail: string;
+  date: string; detail: string;
   kind?: string; topics?: string[]; status: "active" | "stale";
 };

package/src/utils.ts

@@ -4,6 +4,9 @@ import path from "node:path";
 import type { NormalizedMessage } from "./types.js";
 
 export const DEFAULT_AGENT_ID = "main";
+export const DEFAULT_BOOTSTRAP_REPO_NAME = "memory";
+
+const MAX_AGENT_LOGIN_PREFIX_LEN = 32;
 
 export function sha256(v: string): string { return crypto.createHash("sha256").update(v).digest("hex"); }
 
@@ -13,6 +16,16 @@ export function normalizeAgentId(value: string | undefined | null): string {
   return trimmed.replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || DEFAULT_AGENT_ID;
 }
 
+export function buildAgentBootstrapRegistration(agentId: string): { prefixLogin: string; defaultRepoName: string } {
+  const prefixLogin = normalizeAgentId(agentId)
+    .replace(/_/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, MAX_AGENT_LOGIN_PREFIX_LEN)
+    .replace(/-+$/g, "") || DEFAULT_AGENT_ID;
+  return { prefixLogin, defaultRepoName: DEFAULT_BOOTSTRAP_REPO_NAME };
+}
+
 export function sessionScopeKey(sessionId: string, agentId?: string): string {
   return `${normalizeAgentId(agentId)}:${sessionId.trim()}`;
 }