@clawmem-ai/clawmem 0.1.6 → 0.1.8

package/README.md

@@ -36,7 +36,7 @@ openclaw plugins install @clawmem-ai/clawmem
 openclaw gateway restart
 ```
 
-After restart, clawmem auto-provisions a private repo on `git.clawmem.ai` and writes `token` + `repo` back into your config. Memories start accumulating from the next session.
+After restart, clawmem 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.
 
 ---
 
@@ -239,9 +239,15 @@ Minimal config (after auto-provisioning):
         enabled: true,
         config: {
           baseUrl: "https://git.clawmem.ai/api/v3",
-          repo: "owner/repo",
-          token: "<token>",
-          authScheme: "token"
+          authScheme: "token",
+          agents: {
+            main: {
+              baseUrl: "https://git.clawmem.ai/api/v3",
+              repo: "owner/main-memory",
+              token: "<token>",
+              authScheme: "token"
+            }
+          }
         }
       }
     }
@@ -260,6 +266,18 @@ Full config with all options:
         config: {
           baseUrl: "https://git.clawmem.ai/api/v3",
           authScheme: "token",
+          agents: {
+            main: {
+              baseUrl: "https://git.clawmem.ai/api/v3",
+              repo: "owner/main-memory",
+              token: "<token>",
+              authScheme: "token"
+            },
+            coder: {
+              repo: "owner/coder-memory",
+              token: "<token>"
+            }
+          },
           issueTitlePrefix: "Session: ",
           memoryTitlePrefix: "Memory: ",
           defaultLabels: ["source:openclaw"],

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "clawmem",
   "name": "ClawMem",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Mirror OpenClaw sessions into GitHub-compatible issues and comments.",
   "kind": "memory",
   "configSchema": {
@@ -25,6 +25,32 @@
         "type": "string",
         "enum": ["token", "bearer"]
       },
+      "agents": {
+        "type": "object",
+        "default": {},
+        "additionalProperties": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "baseUrl": {
+              "type": "string",
+              "minLength": 1
+            },
+            "repo": {
+              "type": "string",
+              "pattern": "^[^/]+/[^/]+$"
+            },
+            "token": {
+              "type": "string",
+              "minLength": 1
+            },
+            "authScheme": {
+              "type": "string",
+              "enum": ["token", "bearer"]
+            }
+          }
+        }
+      },
       "issueTitlePrefix": {
         "type": "string"
       },
@@ -94,16 +120,20 @@
     "repo": {
       "label": "Repository",
       "placeholder": "owner/repo",
-      "help": "Target repository that stores session issues. If left blank, clawmem will provision one automatically on first start."
+      "help": "Legacy single-route setting. New installs should use per-agent routes under agents.<agentId>."
     },
     "token": {
       "label": "API Token",
       "sensitive": true,
-      "help": "Token used for issue, comment, and label API calls. If left blank, clawmem will provision one automatically on first start."
+      "help": "Legacy single-route setting. New installs should use per-agent routes under agents.<agentId>."
     },
     "authScheme": {
       "label": "Auth Scheme",
-      "help": "Use 'token' for GitHub-style auth or 'bearer' for bearer tokens. Automatically provisioned credentials use 'token'."
+      "help": "Default auth scheme for per-agent routes. Automatically provisioned credentials use 'token'."
+    },
+    "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",

package/package.json

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

package/src/config.ts

@@ -1,6 +1,7 @@
 // Hardcoded label/prefix constants and plugin config resolution.
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
-import type { ClawMemPluginConfig } from "./types.js";
+import type { ClawMemAgentConfig, ClawMemPluginConfig, ClawMemResolvedRoute } from "./types.js";
+import { normalizeAgentId } from "./utils.js";
 
 export const SESSION_TITLE_PREFIX = "Session: ";
 export const MEMORY_TITLE_PREFIX = "Memory: ";
@@ -20,18 +21,46 @@ export function resolvePluginConfig(api: OpenClawPluginApi): ClawMemPluginConfig
   const num = (v: unknown, d: number) => typeof v === "number" && Number.isFinite(v) ? Math.floor(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)
+    ? (raw.agents as Record<string, unknown>)
+    : {};
+  const agents: Record<string, ClawMemAgentConfig> = {};
+  for (const [rawAgentId, rawAgentConfig] of Object.entries(rawAgents)) {
+    if (!rawAgentConfig || typeof rawAgentConfig !== "object" || Array.isArray(rawAgentConfig)) continue;
+    const agentId = normalizeAgentId(rawAgentId);
+    const agent = rawAgentConfig as Record<string, unknown>;
+    agents[agentId] = {
+      baseUrl: str(agent.baseUrl)?.replace(/\/+$/, ""),
+      repo: str(agent.repo),
+      token: str(agent.token),
+      authScheme: agent.authScheme === "bearer" ? "bearer" : agent.authScheme === "token" ? "token" : undefined,
+    };
+  }
   return {
     baseUrl: baseUrl.endsWith("/api/v3") ? baseUrl : `${baseUrl}/api/v3`,
-    repo: str(raw.repo), token: str(raw.token),
     authScheme: raw.authScheme === "bearer" ? "bearer" : "token",
+    agents,
     memoryRecallLimit: clamp(num(raw.memoryRecallLimit, 5), 1, 20),
     turnCommentDelayMs: num(raw.turnCommentDelayMs, 1000),
     summaryWaitTimeoutMs: clamp(num(raw.summaryWaitTimeoutMs, 120000), 1000, 600000),
   };
 }
 
-export function isPluginConfigured(config: ClawMemPluginConfig): boolean {
-  return Boolean(config.baseUrl && config.repo && config.token);
+export function resolveAgentRoute(config: ClawMemPluginConfig, agentId?: string): ClawMemResolvedRoute {
+  const id = normalizeAgentId(agentId);
+  const agent = config.agents[id] ?? {};
+  const baseUrl = (agent.baseUrl ?? config.baseUrl).replace(/\/+$/, "");
+  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,
+  };
+}
+
+export function isAgentConfigured(route: ClawMemResolvedRoute): boolean {
+  return Boolean(route.baseUrl && route.repo && route.token);
 }
 
 export function resolveLabelColor(label: string): string {

package/src/conversation.test.ts

@@ -0,0 +1,76 @@
+// Tests for conversation title derivation logic.
+import { deriveInitialTitle } from "./conversation.js";
+import type { NormalizedMessage } from "./types.js";
+
+function msg(role: string, text: string): NormalizedMessage {
+  return { role, text };
+}
+
+const tests: Array<{ name: string; messages: NormalizedMessage[]; sessionId: string; expected: string | RegExp }> = [
+  {
+    name: "uses first user message",
+    messages: [msg("user", "How do I configure Redis rate limiting?")],
+    sessionId: "abc123",
+    expected: "How do I configure Redis rate limiting?",
+  },
+  {
+    name: "truncates long messages to 50 chars",
+    messages: [msg("user", "I need help with configuring the distributed rate limiting system for our production Redis cluster")],
+    sessionId: "abc123",
+    expected: /^I need help with configuring the distributed rate…$/,
+  },
+  {
+    name: "strips markdown formatting",
+    messages: [msg("user", "## How do I **configure** `Redis` rate limiting?")],
+    sessionId: "abc123",
+    expected: "How do I configure Redis rate limiting?",
+  },
+  {
+    name: "falls back to session ID for short messages",
+    messages: [msg("user", "hi")],
+    sessionId: "abc-def-123",
+    expected: "Session: abc-def-123",
+  },
+  {
+    name: "falls back to session ID when no user messages",
+    messages: [msg("assistant", "Hello!")],
+    sessionId: "xyz-789",
+    expected: "Session: xyz-789",
+  },
+  {
+    name: "falls back to session ID for empty messages",
+    messages: [],
+    sessionId: "empty-sess",
+    expected: "Session: empty-sess",
+  },
+  {
+    name: "collapses whitespace",
+    messages: [msg("user", "How do   I    configure\n\nRedis?")],
+    sessionId: "abc",
+    expected: "How do I configure Redis?",
+  },
+  {
+    name: "skips assistant messages, uses first user message",
+    messages: [msg("assistant", "Welcome!"), msg("user", "Fix the login bug please")],
+    sessionId: "abc",
+    expected: "Fix the login bug please",
+  },
+];
+
+let passed = 0;
+let failed = 0;
+
+for (const t of tests) {
+  const got = deriveInitialTitle(t.messages, t.sessionId);
+  const ok = t.expected instanceof RegExp ? t.expected.test(got) : got === t.expected;
+  if (!ok) {
+    console.error(`FAIL: ${t.name}\n  got:      ${JSON.stringify(got)}\n  expected: ${t.expected instanceof RegExp ? t.expected.toString() : JSON.stringify(t.expected)}`);
+    failed++;
+  } else {
+    console.log(`PASS: ${t.name}`);
+    passed++;
+  }
+}
+
+console.log(`\n${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);

package/src/conversation.ts

@@ -47,7 +47,8 @@ export class ConversationMirror {
       );
       this.resetIssueBinding(session);
     }
-    const title = `${SESSION_TITLE_PREFIX}${session.sessionId}`;
+    // Use first user message as title (truncated), falling back to session ID.
+    const title = deriveInitialTitle(snapshot.messages, session.sessionId);
     const labels = this.buildLabels(session, snapshot, false);
     const body = this.renderBody(session, snapshot, "pending", false);
     await this.client.ensureLabels(labels);
@@ -59,9 +60,10 @@ export class ConversationMirror {
     session.updatedAt = session.createdAt;
   }
 
-  async syncBody(session: SessionMirrorState, snapshot: TranscriptSnapshot, summary: string, closed: boolean): Promise<void> {
+  async syncBody(session: SessionMirrorState, snapshot: TranscriptSnapshot, summary: string, closed: boolean, titleOverride?: string): Promise<void> {
     if (!session.issueNumber) return;
-    const title = `${SESSION_TITLE_PREFIX}${session.sessionId}`;
+    // Prefer explicit override (LLM-generated title), then keep existing title, then fall back to session ID.
+    const title = titleOverride?.trim() || session.issueTitle || `${SESSION_TITLE_PREFIX}${session.sessionId}`;
     const body = this.renderBody(session, snapshot, summary, closed);
     const hash = sha256(`${title}\n${body}\n${closed ? "closed" : "open"}`);
     if (hash === session.lastSummaryHash) return;
@@ -86,22 +88,28 @@ export class ConversationMirror {
     return count;
   }
 
-  async generateSummary(session: SessionMirrorState, snapshot: TranscriptSnapshot): Promise<string> {
+  async generateSummaryAndTitle(session: SessionMirrorState, snapshot: TranscriptSnapshot): Promise<{ summary: string; title?: string }> {
     if (snapshot.messages.length === 0) throw new Error("no conversation messages to summarize");
     const subagent = this.api.runtime.subagent;
     const sessionKey = subKey(session, "summary");
     const message = [
-      "Summarize the following conversation.",
-      'Return valid JSON only in the form {"summary":"..."}',
+      "Summarize the following conversation and generate a short title.",
+      'Return valid JSON only in the form {"summary":"...","title":"..."}',
       "The summary should be concise, factual, and written in 2-4 sentences.",
       "Do not include markdown, bullet points, or analysis.",
+      "",
+      "Title rules:",
+      "- Under 50 characters, evocative like a good article headline.",
+      "- Should make someone curious to read the conversation.",
+      "- Must be in the same language as the majority of the conversation content.",
+      "- Good: creative, captures the spirit. Bad: dry meeting-minutes style.",
       "", "<conversation>", fmtTranscript(snapshot.messages), "</conversation>",
     ].join("\n");
     try {
       const run = await subagent.run({
         sessionKey, message, deliver: false, lane: "clawmem-summary",
-        idempotencyKey: sha256(`${session.sessionId}:${snapshot.messages.length}:summary`),
-        extraSystemPrompt: "You summarize OpenClaw conversations. Output JSON only with one string field named summary.",
+        idempotencyKey: sha256(`${session.sessionId}:${snapshot.messages.length}:summary-v2`),
+        extraSystemPrompt: "You summarize OpenClaw conversations and generate evocative titles. Output JSON only with string fields summary and title.",
       });
       const wait = await subagent.waitForRun({ runId: run.runId, timeoutMs: this.config.summaryWaitTimeoutMs });
       if (wait.status === "timeout") throw new Error("summary subagent timed out");
@@ -109,7 +117,7 @@ export class ConversationMirror {
       const msgs = normalizeMessages((await subagent.getSessionMessages({ sessionKey, limit: 50 })).messages);
       const text = [...msgs].reverse().find((e) => e.role === "assistant" && e.text.trim())?.text;
       if (!text) throw new Error("summary subagent returned no assistant text");
-      return parseSummary(text);
+      return parseSummaryAndTitle(text);
     } finally { subagent.deleteSession({ sessionKey, deleteTranscript: true }).catch(() => {}); }
   }
 
@@ -184,11 +192,36 @@ function isNotFoundError(error: unknown): boolean {
   const text = String(error);
   return text.includes("HTTP 404");
 }
-function parseSummary(raw: string): string {
-  const tryParse = (s: string): string | null => {
-    try { const p = JSON.parse(s) as { summary?: unknown }; return typeof p?.summary === "string" && p.summary.trim() ? p.summary.trim() : null; }
-    catch { const i = s.indexOf("{"), j = s.lastIndexOf("}");
-      if (i >= 0 && j > i) { try { const p = JSON.parse(s.slice(i, j + 1)) as { summary?: unknown }; return typeof p?.summary === "string" && p.summary.trim() ? p.summary.trim() : null; } catch { return null; } }
+/** Derive a conversation title from the first user message, truncated to 50 chars. */
+export function deriveInitialTitle(messages: NormalizedMessage[], sessionId: string): string {
+  const firstUserMsg = messages.find((m) => m.role === "user")?.text?.trim() ?? "";
+  // Strip markdown, collapse whitespace.
+  const clean = firstUserMsg.replace(/[#*`~>|]/g, "").replace(/\s+/g, " ").trim();
+  if (clean.length >= 5) {
+    return clean.length <= 50 ? clean : clean.slice(0, 49).trimEnd() + "…";
+  }
+  return `${SESSION_TITLE_PREFIX}${sessionId}`;
+}
+
+function parseSummaryAndTitle(raw: string): { summary: string; title?: string } {
+  const tryParse = (s: string): { summary: string; title?: string } | null => {
+    try {
+      const p = JSON.parse(s) as { summary?: unknown; title?: unknown };
+      const summary = typeof p?.summary === "string" && p.summary.trim() ? p.summary.trim() : null;
+      if (!summary) return null;
+      const title = typeof p?.title === "string" && p.title.trim() ? p.title.trim() : undefined;
+      return { summary, title };
+    } catch {
+      const i = s.indexOf("{"), j = s.lastIndexOf("}");
+      if (i >= 0 && j > i) {
+        try {
+          const p = JSON.parse(s.slice(i, j + 1)) as { summary?: unknown; title?: unknown };
+          const summary = typeof p?.summary === "string" && p.summary.trim() ? p.summary.trim() : null;
+          if (!summary) return null;
+          const title = typeof p?.title === "string" && p.title.trim() ? p.title.trim() : undefined;
+          return { summary, title };
+        } catch { return null; }
+      }
       return null;
     }
   };
@@ -196,5 +229,5 @@ function parseSummary(raw: string): string {
   const direct = tryParse(t); if (direct) return direct;
   const f = /^```(?:json)?\s*([\s\S]*?)```$/i.exec(t);
   if (f?.[1]) { const nested = tryParse(f[1].trim()); if (nested) return nested; }
-  return t;
+  return { summary: t };
 }

package/src/github-client.ts

@@ -1,12 +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, ClawMemPluginConfig } from "./types.js";
+import type { AnonymousSessionResponse, ClawMemResolvedRoute } from "./types.js";
 
 type IssueResponse = { number: number; title?: string; body?: string; state?: string; labels?: Array<{ name?: string } | string> };
 type ReqOpts = { allowNotFound?: boolean; allowValidationError?: boolean; omitAuth?: boolean };
 
 export class GitHubIssueClient {
-  constructor(private readonly config: ClawMemPluginConfig, private readonly log: { warn?: (msg: string) => void }) {}
+  constructor(private readonly config: ClawMemResolvedRoute, private readonly log: { warn?: (msg: string) => void }) {}
 
   async createIssue(params: { title: string; body: string; labels: string[] }): Promise<IssueResponse> {
     return this.req<IssueResponse>(this.repoPath("issues"), { method: "POST", body: JSON.stringify(params) });
@@ -38,8 +38,15 @@ export class GitHubIssueClient {
     const unmanaged = extractLabelNames(issue.labels).filter((l) => !isManagedLabel(l));
     await this.updateIssue(issueNumber, { labels: [...new Set([...unmanaged, ...desired])] });
   }
-  async createAnonymousSession(): Promise<AnonymousSessionResponse> {
-    return this.req<AnonymousSessionResponse>("anonymous/session", { method: "POST" }, { omitAuth: true });
+  async getRepoInfo(): Promise<{ description?: string; name?: string }> {
+    return this.req<{ description?: string; name?: string }>(this.repoPath("").replace(/\/$/, ""), { method: "GET" });
+  }
+  async updateRepoDescription(description: string): Promise<void> {
+    await this.req(this.repoPath("").replace(/\/$/, ""), { method: "PATCH", body: JSON.stringify({ description }) });
+  }
+  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 });
   }
 
   private repoPath(suffix: string): string {

package/src/service.ts

@@ -1,6 +1,6 @@
 // Thin orchestrator: wires conversation mirroring, memory store, and plugin lifecycle.
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
-import { isPluginConfigured, resolvePluginConfig } from "./config.js";
+import { isAgentConfigured, resolveAgentRoute, resolvePluginConfig } from "./config.js";
 import { ConversationMirror } from "./conversation.js";
 import { GitHubIssueClient } from "./github-client.js";
 import { KeyedAsyncQueue } from "./keyed-async-queue.js";
@@ -8,34 +8,29 @@ 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";
 
 type TurnPayload = { sessionId?: string; sessionKey?: string; agentId?: string; messages: unknown[] };
 type FinalizePayload = { sessionId?: string; sessionKey?: string; sessionFile?: string; agentId?: string; reason?: string; messages?: unknown[] };
 
 class ClawMemService {
   private readonly config: ClawMemPluginConfig;
-  private readonly client: GitHubIssueClient;
-  private readonly conv: ConversationMirror;
-  private readonly mem: MemoryStore;
   private readonly queue = new KeyedAsyncQueue();
   private readonly stateQueue = new KeyedAsyncQueue();
   private readonly pending = new Set<Promise<unknown>>();
   private readonly syncTimers = new Map<string, ReturnType<typeof setTimeout>>();
   private statePath = "";
-  private state: PluginState = { version: 1, sessions: {} };
+  private state: PluginState = { version: 2, sessions: {} };
   private unsubTranscript?: () => void;
   private loadPromise: Promise<void> | null = null;
-  private configPromise: Promise<boolean> | null = null;
+  private readonly configPromises = new Map<string, Promise<boolean>>();
 
   constructor(private readonly api: OpenClawPluginApi) {
     this.config = resolvePluginConfig(api);
-    this.client = new GitHubIssueClient(this.config, api.logger);
-    this.conv = new ConversationMirror(this.client, api, this.config);
-    this.mem = new MemoryStore(this.client, api, this.config);
   }
 
   register(): void {
-    this.api.on("before_agent_start", async (ev) => this.handleRecall(ev.prompt));
+    this.api.on("before_agent_start", async (ev, ctx) => this.handleRecall(ev.prompt, ctx.agentId));
     this.api.on("agent_end", (ev, ctx) => this.scheduleTurn({ sessionId: ctx.sessionId, sessionKey: ctx.sessionKey, agentId: ctx.agentId, messages: ev.messages }));
     this.api.on("before_reset", (ev, ctx) => this.enqueueFinalize({ sessionId: ctx.sessionId, sessionKey: ctx.sessionKey, sessionFile: ev.sessionFile, agentId: ctx.agentId, reason: ev.reason, messages: ev.messages }));
     this.api.on("session_end", (ev, ctx) => this.enqueueFinalize({ sessionId: ev.sessionId ?? ctx.sessionId, sessionKey: ev.sessionKey ?? ctx.sessionKey, agentId: ctx.agentId, reason: "session_end" }));
@@ -45,12 +40,17 @@ class ClawMemService {
       start: async (ctx) => {
         this.statePath = resolveStatePath(ctx.stateDir);
         await this.ensureLoaded();
-        const ok = await this.ensureConfigured();
         this.unsubTranscript = this.api.runtime.events.onSessionTranscriptUpdate((u) => {
           void this.track(this.handleTranscript(u.sessionFile)).catch((e) => this.warn("transcript update", e));
         });
-        if (ok) this.api.logger.info?.(`clawmem: mirroring sessions to ${this.config.repo} via ${this.config.baseUrl}`);
-        else this.api.logger.warn(`clawmem: missing repo/token and automatic provisioning failed via ${this.config.baseUrl}; sync will retry on the next use`);
+        const configuredCount = Object.keys(this.config.agents).filter((agentId) => {
+          return isAgentConfigured(resolveAgentRoute(this.config, agentId));
+        }).length;
+        this.api.logger.info?.(
+          configuredCount > 0
+            ? `clawmem: ready with ${configuredCount} configured agent route(s); missing routes will provision on first use via ${this.config.baseUrl}`
+            : `clawmem: ready; agent routes will provision on first use via ${this.config.baseUrl}`,
+        );
       },
       stop: async () => {
         this.unsubTranscript?.();
@@ -61,11 +61,13 @@ class ClawMemService {
     });
   }
 
-  private async handleRecall(prompt: unknown): Promise<{ prependContext: string } | void> {
+  private async handleRecall(prompt: unknown, agentId?: string): Promise<{ prependContext: string } | void> {
     if (typeof prompt !== "string" || prompt.trim().length < 5) return;
-    if (!(await this.ensureConfigured())) return;
+    const routeAgentId = normalizeAgentId(agentId);
+    if (!(await this.ensureConfigured(routeAgentId))) return;
     try {
-      const memories = await this.mem.search(prompt, this.config.memoryRecallLimit);
+      const { mem } = this.getServices(routeAgentId);
+      const memories = await mem.search(prompt, this.config.memoryRecallLimit);
       if (memories.length === 0) return;
       const text = memories.map((m) => `- ${m.detail}`).join("\n");
       return { prependContext: `<relevant-memories>\nThe following active memories may be relevant to this conversation:\n${text}\n</relevant-memories>` };
@@ -75,69 +77,94 @@ class ClawMemService {
   private async handleTranscript(sessionFile: string): Promise<void> {
     let snap: TranscriptSnapshot;
     try { snap = await readTranscriptSnapshot(sessionFile); } catch (e) { this.warn("transcript read", e); return; }
-    if (!snap.sessionId || !this.conv.shouldMirror(snap.sessionId, snap.messages)) return;
-    if (!(await this.ensureConfigured())) return;
-    await this.enqueueSession(snap.sessionId, async () => {
-      const s = this.getOrCreate(snap.sessionId!);
+    if (!snap.sessionId) return;
+    const agentId = this.resolveTranscriptAgentId(snap.sessionId, sessionFile);
+    if (!agentId) {
+      this.api.logger.info?.(
+        `clawmem: skipping transcript sync for ${snap.sessionId} because agent ownership could not be inferred from ${sessionFile}`,
+      );
+      return;
+    }
+    const { conv } = this.getServices(agentId);
+    if (!conv.shouldMirror(snap.sessionId, snap.messages)) return;
+    if (!(await this.ensureConfigured(agentId))) return;
+    await this.enqueueSession(sessionScopeKey(snap.sessionId, agentId), async () => {
+      const s = this.getOrCreate(snap.sessionId!, agentId);
       s.sessionFile = sessionFile;
       s.updatedAt = new Date().toISOString();
-      await this.conv.ensureIssue(s, snap);
+      await conv.ensureIssue(s, snap);
       await this.persistState();
     });
   }
 
   private scheduleTurn(p: TurnPayload): void {
     if (!p.sessionId) return;
-    const prev = this.syncTimers.get(p.sessionId);
+    const scopeKey = sessionScopeKey(p.sessionId, p.agentId);
+    const prev = this.syncTimers.get(scopeKey);
     if (prev) clearTimeout(prev);
     const timer = setTimeout(() => {
-      this.syncTimers.delete(p.sessionId!);
-      void this.track(this.enqueueSession(p.sessionId!, () => this.syncTurn(p))).catch((e) => this.warn("turn sync", e));
+      this.syncTimers.delete(scopeKey);
+      void this.track(this.enqueueSession(scopeKey, () => this.syncTurn(p))).catch((e) => this.warn("turn sync", e));
     }, this.config.turnCommentDelayMs);
     timer.unref?.();
-    this.syncTimers.set(p.sessionId, timer);
+    this.syncTimers.set(scopeKey, timer);
   }
 
   private async syncTurn(p: TurnPayload): Promise<void> {
-    if (!p.sessionId || !(await this.ensureConfigured())) return;
-    const s = this.getOrCreate(p.sessionId);
-    s.sessionKey = p.sessionKey ?? s.sessionKey; s.agentId = p.agentId ?? s.agentId; s.updatedAt = new Date().toISOString();
-    const snap = await this.conv.loadSnapshot(s, p.messages);
-    if (!this.conv.shouldMirror(s.sessionId, snap.messages) || snap.messages.length === 0) { await this.persistState(); return; }
-    await this.conv.ensureIssue(s, snap);
-    await this.conv.syncLabels(s, snap, false);
+    if (!p.sessionId) return;
+    const agentId = normalizeAgentId(p.agentId);
+    if (!(await this.ensureConfigured(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();
+    const snap = await conv.loadSnapshot(s, p.messages);
+    if (!conv.shouldMirror(s.sessionId, snap.messages) || snap.messages.length === 0) { await this.persistState(); return; }
+    await conv.ensureIssue(s, snap);
+    await conv.syncLabels(s, snap, false);
     const next = snap.messages.slice(s.lastMirroredCount);
-    if (next.length > 0) { const n = await this.conv.appendComments(s.issueNumber!, next); s.lastMirroredCount += n; s.turnCount += n; }
+    if (next.length > 0) { const n = await conv.appendComments(s.issueNumber!, next); s.lastMirroredCount += n; s.turnCount += n; }
     await this.persistState();
   }
 
   private enqueueFinalize(p: FinalizePayload): void {
     if (!p.sessionId) return;
-    const prev = this.syncTimers.get(p.sessionId);
-    if (prev) { clearTimeout(prev); this.syncTimers.delete(p.sessionId); }
-    void this.track(this.enqueueSession(p.sessionId, () => this.finalize(p))).catch((e) => this.warn("finalize", e));
+    const scopeKey = sessionScopeKey(p.sessionId, p.agentId);
+    const prev = this.syncTimers.get(scopeKey);
+    if (prev) { clearTimeout(prev); this.syncTimers.delete(scopeKey); }
+    void this.track(this.enqueueSession(scopeKey, () => this.finalize(p))).catch((e) => this.warn("finalize", e));
   }
 
   private async finalize(p: FinalizePayload): Promise<void> {
-    if (!p.sessionId || !(await this.ensureConfigured())) return;
-    const s = this.getOrCreate(p.sessionId);
+    if (!p.sessionId) return;
+    const agentId = normalizeAgentId(p.agentId);
+    if (!(await this.ensureConfigured(agentId))) return;
+    const { conv, mem } = this.getServices(agentId);
+    const s = this.getOrCreate(p.sessionId, agentId);
     if (s.finalizedAt) return;
     s.sessionKey = p.sessionKey ?? s.sessionKey; s.sessionFile = p.sessionFile ?? s.sessionFile;
-    s.agentId = p.agentId ?? s.agentId; s.updatedAt = new Date().toISOString();
-    const snap = await this.conv.loadSnapshot(s, p.messages ?? []);
-    if (!this.conv.shouldMirror(s.sessionId, snap.messages)) { await this.persistState(); return; }
+    s.agentId = agentId; s.updatedAt = new Date().toISOString();
+    const snap = await conv.loadSnapshot(s, p.messages ?? []);
+    if (!conv.shouldMirror(s.sessionId, snap.messages)) { await this.persistState(); return; }
     if (snap.messages.length === 0 && !s.issueNumber) { await this.persistState(); return; }
-    await this.conv.ensureIssue(s, snap);
+    await conv.ensureIssue(s, snap);
     const next = snap.messages.slice(s.lastMirroredCount);
     let allOk = true;
-    if (next.length > 0) { const n = await this.conv.appendComments(s.issueNumber!, next); s.lastMirroredCount += n; s.turnCount += n; allOk = n === next.length; }
+    if (next.length > 0) { const n = await conv.appendComments(s.issueNumber!, next); s.lastMirroredCount += n; s.turnCount += n; allOk = n === next.length; }
     let summary = "pending";
-    try { summary = await this.conv.generateSummary(s, snap); } catch (e) { summary = `failed: ${String(e)}`; }
-    await this.conv.syncLabels(s, snap, true);
-    await this.conv.syncBody(s, snap, summary, true);
-    await this.mem.syncFromConversation(s, snap);
+    let generatedTitle: string | undefined;
+    try {
+      const result = await conv.generateSummaryAndTitle(s, snap);
+      summary = result.summary;
+      generatedTitle = result.title;
+    } catch (e) { summary = `failed: ${String(e)}`; }
+    await conv.syncLabels(s, snap, true);
+    await conv.syncBody(s, snap, summary, true, generatedTitle);
+    await mem.syncFromConversation(s, snap);
     if (allOk) s.finalizedAt = new Date().toISOString();
     await this.persistState();
+
+    // Auto-name the repo if it still has no description (first few conversations).
+    this.maybeAutoNameRepo(agentId, summary, generatedTitle);
   }
 
   // --- Infrastructure ---
@@ -155,13 +182,32 @@ class ClawMemService {
     );
     return promise;
   }
-  private getOrCreate(sessionId: string): SessionMirrorState {
-    if (this.state.sessions[sessionId]) return this.state.sessions[sessionId];
+  private getOrCreate(sessionId: string, agentId?: string): SessionMirrorState {
+    const scopeKey = sessionScopeKey(sessionId, agentId);
+    if (this.state.sessions[scopeKey]) return this.state.sessions[scopeKey];
     const now = new Date().toISOString();
-    const s: SessionMirrorState = { sessionId, lastMirroredCount: 0, turnCount: 0, createdAt: now, updatedAt: now };
-    this.state.sessions[sessionId] = s;
+    const s: SessionMirrorState = {
+      sessionId,
+      agentId: normalizeAgentId(agentId),
+      lastMirroredCount: 0,
+      turnCount: 0,
+      createdAt: now,
+      updatedAt: now,
+    };
+    this.state.sessions[scopeKey] = s;
     return s;
   }
+  private resolveTranscriptAgentId(sessionId: string, sessionFile: string): string | null {
+    const fromPath = inferAgentIdFromTranscriptPath(sessionFile);
+    if (fromPath) return fromPath;
+    const knownAgents = new Set(
+      Object.values(this.state.sessions)
+        .filter((session) => session.sessionId === sessionId)
+        .map((session) => normalizeAgentId(session.agentId)),
+    );
+    if (knownAgents.size === 1) return [...knownAgents][0] ?? null;
+    return null;
+  }
   private async persistState(): Promise<void> {
     if (!this.statePath) this.statePath = resolveStatePath(this.api.runtime.state.resolveStateDir());
     await this.stateQueue.enqueue("state", () => saveState(this.statePath, this.state));
@@ -174,29 +220,83 @@ class ClawMemService {
     })();
     return this.loadPromise;
   }
-  private async ensureConfigured(): Promise<boolean> {
-    if (isPluginConfigured(this.config)) return true;
-    if (this.configPromise) return this.configPromise;
-    const p = this.bootstrap();
-    this.configPromise = p;
-    try { return await p; } finally { if (this.configPromise === p) this.configPromise = null; }
+  private async ensureConfigured(agentId?: string): Promise<boolean> {
+    const id = normalizeAgentId(agentId);
+    if (isAgentConfigured(resolveAgentRoute(this.config, id))) return true;
+    const pending = this.configPromises.get(id);
+    if (pending) return pending;
+    const p = this.bootstrap(id);
+    this.configPromises.set(id, p);
+    try { return await p; } finally { if (this.configPromises.get(id) === p) this.configPromises.delete(id); }
   }
-  private async bootstrap(): Promise<boolean> {
-    if (!this.config.baseUrl) { this.api.logger.warn("clawmem: cannot provision Git credentials without a baseUrl"); return false; }
+  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 sess = await this.client.createAnonymousSession();
-      await this.persistPluginConfig({ baseUrl: this.config.baseUrl, authScheme: "token", token: sess.token, repo: sess.repo_full_name });
-      this.config.authScheme = "token"; this.config.token = sess.token; this.config.repo = sess.repo_full_name;
-      this.api.logger.info?.(`clawmem: provisioned Git credentials for ${sess.repo_full_name} via ${this.config.baseUrl}`);
+      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}`);
       return true;
-    } catch (error) { this.api.logger.warn(`clawmem: failed to provision Git credentials via ${this.config.baseUrl}: ${String(error)}`); return false; }
+    } catch (error) { this.api.logger.warn(`clawmem: failed to provision Git credentials for agent ${agentId} via ${route.baseUrl}: ${String(error)}`); return false; }
   }
-  private async persistPluginConfig(values: Partial<ClawMemPluginConfig>): Promise<void> {
+  private async persistAgentConfig(agentId: string, values: { baseUrl: string; authScheme: "token" | "bearer"; token: string; repo: 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>) : {};
     const ex = asRecord(entries[this.api.id]), exCfg = asRecord(ex.config);
-    await this.api.runtime.config.writeConfigFile({ ...root, plugins: { ...(plugins ?? {}), entries: { ...entries, [this.api.id]: { ...ex, config: { ...exCfg, ...values } } } } });
+    const agents = exCfg.agents && typeof exCfg.agents === "object" && !Array.isArray(exCfg.agents) ? (exCfg.agents as Record<string, unknown>) : {};
+    const existingAgent = asRecord(agents[agentId]);
+    await this.api.runtime.config.writeConfigFile({
+      ...root,
+      plugins: {
+        ...(plugins ?? {}),
+        entries: {
+          ...entries,
+          [this.api.id]: {
+            ...ex,
+            config: {
+              ...exCfg,
+              agents: {
+                ...agents,
+                [agentId]: { ...existingAgent, ...values },
+              },
+            },
+          },
+        },
+      },
+    });
+  }
+  private getServices(agentId?: string): { conv: ConversationMirror; mem: MemoryStore } {
+    const client = new GitHubIssueClient(resolveAgentRoute(this.config, agentId), this.api.logger);
+    return {
+      conv: new ConversationMirror(client, this.api, this.config),
+      mem: new MemoryStore(client, this.api, this.config),
+    };
+  }
+  /**
+   * 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
+   * the repo description automatically. Best-effort, fire-and-forget.
+   */
+  private maybeAutoNameRepo(agentId: string, summary: string, title?: string): void {
+    if (!summary || summary.startsWith("failed:") || summary === "pending") return;
+    const snippet = title || summary.slice(0, 100);
+    void (async () => {
+      try {
+        const client = new GitHubIssueClient(resolveAgentRoute(this.config, agentId), this.api.logger);
+        const repo = await client.getRepoInfo();
+        // Only auto-name if description is still empty or a default placeholder.
+        if (repo.description && repo.description !== "My Memory Space" && repo.description !== "我的记忆空间" && repo.description !== "マイメモリースペース") return;
+        // Use the conversation title or summary as a lightweight description.
+        await client.updateRepoDescription(snippet);
+        this.api.logger.info?.(`clawmem: auto-named repo to "${snippet}"`);
+      } catch (e) {
+        this.api.logger.warn(`clawmem: auto-name repo failed: ${String(e)}`);
+      }
+    })();
   }
   private warn(scope: string, error: unknown): void { this.api.logger.warn(`clawmem: ${scope} failed: ${String(error)}`); }
 }

package/src/state.ts

@@ -1,9 +1,10 @@
 import fs from "node:fs";
 import path from "node:path";
 import type { PluginState } from "./types.js";
+import { normalizeAgentId, sessionScopeKey } from "./utils.js";
 
 const EMPTY_STATE: PluginState = {
-  version: 1,
+  version: 2,
   sessions: {},
 };
 
@@ -42,19 +43,24 @@ function sanitizeState(value: unknown): PluginState {
       ? (raw.sessions as Record<string, unknown>)
       : {};
   const out: PluginState = {
-    version: 1,
+    version: 2,
     sessions: {},
   };
-  for (const [sessionId, sessionValue] of Object.entries(sessions)) {
-    if (!sessionValue || typeof sessionValue !== "object" || !sessionId.trim()) {
+  for (const [storedKey, sessionValue] of Object.entries(sessions)) {
+    if (!sessionValue || typeof sessionValue !== "object" || !storedKey.trim()) {
       continue;
     }
     const rawSession = sessionValue as Record<string, unknown>;
-    out.sessions[sessionId] = {
+    const sessionId = readString(rawSession.sessionId) ?? storedKey.trim();
+    if (!sessionId) {
+      continue;
+    }
+    const agentId = normalizeAgentId(readString(rawSession.agentId));
+    out.sessions[sessionScopeKey(sessionId, agentId)] = {
       sessionId,
       sessionKey: readString(rawSession.sessionKey),
       sessionFile: readString(rawSession.sessionFile),
-      agentId: readString(rawSession.agentId),
+      agentId,
       issueNumber: readNumber(rawSession.issueNumber),
       issueTitle: readString(rawSession.issueTitle),
       lastMirroredCount: readNumber(rawSession.lastMirroredCount) ?? 0,

package/src/types.ts

@@ -1,10 +1,28 @@
 // Shared types for the clawmem plugin.
+export type ClawMemAgentConfig = {
+  baseUrl?: string;
+  repo?: string;
+  token?: string;
+  authScheme?: "token" | "bearer";
+};
+
 export type ClawMemPluginConfig = {
-  baseUrl?: string; repo?: string; token?: string;
+  baseUrl: string;
   authScheme: "token" | "bearer";
-  memoryRecallLimit: number; turnCommentDelayMs: number;
+  agents: Record<string, ClawMemAgentConfig>;
+  memoryRecallLimit: number;
+  turnCommentDelayMs: number;
   summaryWaitTimeoutMs: number;
 };
+
+export type ClawMemResolvedRoute = {
+  agentId: string;
+  baseUrl: 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 SessionMirrorState = {
   sessionId: string; sessionKey?: string; sessionFile?: string; agentId?: string;
@@ -13,7 +31,7 @@ export type SessionMirrorState = {
   finalizedAt?: string; lastSummaryHash?: string; lastTurnHash?: string;
   createdAt?: string; updatedAt?: string;
 };
-export type PluginState = { version: 1; sessions: Record<string, SessionMirrorState> };
+export type PluginState = { version: 2; sessions: Record<string, SessionMirrorState> };
 export type NormalizedMessage = { role: string; text: string; toolName?: string; timestamp?: string; stopReason?: string };
 export type TranscriptSnapshot = { sessionId?: string; messages: NormalizedMessage[] };
 export type ParsedMemoryIssue = {

package/src/utils.ts

@@ -1,9 +1,29 @@
 // Shared utility helpers used by memory.ts and conversation.ts.
 import crypto from "node:crypto";
+import path from "node:path";
 import type { NormalizedMessage } from "./types.js";
 
+export const DEFAULT_AGENT_ID = "main";
+
 export function sha256(v: string): string { return crypto.createHash("sha256").update(v).digest("hex"); }
 
+export function normalizeAgentId(value: string | undefined | null): string {
+  const trimmed = (value ?? "").trim().toLowerCase();
+  if (!trimmed) return DEFAULT_AGENT_ID;
+  return trimmed.replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || DEFAULT_AGENT_ID;
+}
+
+export function sessionScopeKey(sessionId: string, agentId?: string): string {
+  return `${normalizeAgentId(agentId)}:${sessionId.trim()}`;
+}
+
+export function inferAgentIdFromTranscriptPath(filePath: string): string | undefined {
+  const parts = path.resolve(filePath).split(path.sep);
+  const idx = parts.lastIndexOf("agents");
+  if (idx < 0 || !parts[idx + 1] || parts[idx + 2] !== "sessions") return undefined;
+  return normalizeAgentId(parts[idx + 1]);
+}
+
 export function subKey(s: { sessionId: string; agentId?: string }, suffix: string): string {
   const san = (v: string) => v.replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48) || "main";
   return `agent:${san(s.agentId || "main")}:subagent:clawmem-${suffix}-${san(s.sessionId)}`;