@clawmem-ai/clawmem 0.1.7 → 0.1.9

package/src/service.ts

@@ -30,16 +30,18 @@ class ClawMemService {
   }
 
   register(): void {
-    this.api.on("before_agent_start", async (ev, ctx) => this.handleRecall(ev.prompt, ctx.agentId));
+    this.api.on("before_agent_start", async (ev, ctx) => this.handleBeforeAgentStart(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" }));
+    this.registerTools();
 
     this.api.registerService({
       id: "clawmem",
-      start: async (ctx) => {
+      start: async (ctx: { stateDir: string }) => {
         this.statePath = resolveStatePath(ctx.stateDir);
         await this.ensureLoaded();
+        this.warnIfInactiveMemorySlot();
         this.unsubTranscript = this.api.runtime.events.onSessionTranscriptUpdate((u) => {
           void this.track(this.handleTranscript(u.sessionFile)).catch((e) => this.warn("transcript update", e));
         });
@@ -61,10 +63,254 @@ class ClawMemService {
     });
   }
 
-  private async handleRecall(prompt: unknown, agentId?: string): Promise<{ prependContext: string } | void> {
-    if (typeof prompt !== "string" || prompt.trim().length < 5) return;
+  private registerTools(): void {
+    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.",
+      required: true,
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          status: { type: "string", enum: ["active", "stale", "all"], description: "Which memories to list. Defaults to active." },
+          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." },
+          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 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 });
+        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})` : ""}.`);
+        }
+        const lines = [
+          `Found ${memories.length} ${status === "all" ? "" : `${status} `}memor${memories.length === 1 ? "y" : "ies"}:`,
+          ...memories.map((memory) => `- ${renderMemoryLine(memory)}`),
+        ];
+        return toolText(lines.join("\n"));
+      },
+    });
+
+    this.api.registerTool({
+      name: "memory_labels",
+      description: "List existing ClawMem schema labels so the agent can reuse current kinds and topics before adding new ones.",
+      required: true,
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          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." },
+        },
+      },
+      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 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:",
+          "",
+          "Kinds:",
+          kinds,
+          "",
+          "Topics:",
+          `${topics}${extra}`,
+        ].join("\n"));
+      },
+    });
+
+    this.api.registerTool({
+      name: "memory_recall",
+      description: "Search ClawMem active memories for relevant prior facts, decisions, conventions, and lessons.",
+      required: true,
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        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." },
+          agentId: { type: "string", minLength: 1, description: "Optional agent route override. Defaults to the current agent when available." },
+        },
+        required: ["query"],
+      },
+      execute: async (_id: string, params: unknown) => {
+        const p = asRecord(params);
+        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 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 text = [
+          `Found ${memories.length} active memor${memories.length === 1 ? "y" : "ies"} for "${query}":`,
+          ...memories.map((memory) => `- ${renderMemoryLine(memory)}`),
+        ].join("\n");
+        return toolText(text);
+      },
+    });
+
+    this.api.registerTool({
+      name: "memory_get",
+      description: "Fetch one ClawMem memory by memory id or issue number so the agent can verify an exact record.",
+      required: true,
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        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." },
+          agentId: { type: "string", minLength: 1, description: "Optional agent route override. Defaults to the current agent when available." },
+        },
+        required: ["memoryId"],
+      },
+      execute: async (_id: string, params: unknown) => {
+        const p = asRecord(params);
+        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 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));
+      },
+    });
+
+    this.api.registerTool({
+      name: "memory_store",
+      description: "Store a durable ClawMem memory immediately instead of waiting for session finalization.",
+      required: true,
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          detail: { type: "string", minLength: 1, description: "The durable fact, lesson, decision, or preference to remember." },
+          kind: { type: "string", minLength: 1, description: "Optional schema kind, for example lesson, convention, skill, or task." },
+          topics: {
+            type: "array",
+            description: "Optional topic labels to improve future retrieval.",
+            items: { type: "string", minLength: 1 },
+            minItems: 1,
+            maxItems: 10,
+          },
+          sessionId: { type: "string", minLength: 1, description: "Optional source session id label. Defaults to manual." },
+          agentId: { type: "string", minLength: 1, description: "Optional agent route override. Defaults to the current agent when available." },
+        },
+        required: ["detail"],
+      },
+      execute: async (_id: string, params: unknown) => {
+        const p = asRecord(params);
+        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 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)}`);
+      },
+    });
+
+    this.api.registerTool({
+      name: "memory_update",
+      description: "Update an existing ClawMem memory in place when the same canonical fact or task has evolved.",
+      required: true,
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          memoryId: { type: "string", minLength: 1, description: "The memory id or issue number to update." },
+          detail: { type: "string", minLength: 1, description: "Optional replacement detail text for the same memory record." },
+          kind: { type: "string", minLength: 1, description: "Optional replacement kind label." },
+          topics: {
+            type: "array",
+            description: "Optional replacement topic labels.",
+            items: { type: "string", minLength: 1 },
+            minItems: 1,
+            maxItems: 10,
+          },
+          agentId: { type: "string", minLength: 1, description: "Optional agent route override. Defaults to the current agent when available." },
+        },
+        required: ["memoryId"],
+      },
+      execute: async (_id: string, params: unknown) => {
+        const p = asRecord(params);
+        const memoryId = typeof p.memoryId === "string" ? p.memoryId.trim() : "";
+        if (!memoryId) return toolText("memoryId is empty.");
+        const detail = typeof p.detail === "string" && p.detail.trim() ? p.detail.trim() : undefined;
+        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;
+        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);
+        let updated;
+        try {
+          updated = await 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)}`);
+      },
+    });
+
+    this.api.registerTool({
+      name: "memory_forget",
+      description: "Mark an active ClawMem memory as stale when it is superseded or no longer true.",
+      required: true,
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          memoryId: { type: "string", minLength: 1, description: "The memory id or issue number to mark stale." },
+          agentId: { type: "string", minLength: 1, description: "Optional agent route override. Defaults to the current agent when available." },
+        },
+        required: ["memoryId"],
+      },
+      execute: async (_id: string, params: unknown) => {
+        const p = asRecord(params);
+        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}`);
+      },
+    });
+  }
+
+  private async handleBeforeAgentStart(prompt: unknown, agentId?: string): Promise<{ prependContext: string } | void> {
     const routeAgentId = normalizeAgentId(agentId);
     if (!(await this.ensureConfigured(routeAgentId))) return;
+    await this.runRequestMaintenance(routeAgentId);
+    if (typeof prompt !== "string" || prompt.trim().length < 5) return;
     try {
       const { mem } = this.getServices(routeAgentId);
       const memories = await mem.search(prompt, this.config.memoryRecallLimit);
@@ -138,7 +384,7 @@ class ClawMemService {
     if (!p.sessionId) return;
     const agentId = normalizeAgentId(p.agentId);
     if (!(await this.ensureConfigured(agentId))) return;
-    const { conv, mem } = this.getServices(agentId);
+    const { conv } = 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;
@@ -150,11 +396,9 @@ class ClawMemService {
     const next = snap.messages.slice(s.lastMirroredCount);
     let allOk = true;
     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 conv.generateSummary(s, snap); } catch (e) { summary = `failed: ${String(e)}`; }
     await conv.syncLabels(s, snap, true);
-    await conv.syncBody(s, snap, summary, true);
-    await mem.syncFromConversation(s, snap);
+    await conv.syncBody(s, snap, "pending", true);
+    s.summaryStatus = "pending";
     if (allOk) s.finalizedAt = new Date().toISOString();
     await this.persistState();
   }
@@ -226,13 +470,35 @@ class ClawMemService {
     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 sess = await client.createAnonymousSession();
+      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 for agent ${agentId} via ${route.baseUrl}: ${String(error)}`); return false; }
   }
+  private warnIfInactiveMemorySlot(): void {
+    try {
+      const root = this.api.runtime.config.loadConfig();
+      const plugins = asRecord(root.plugins);
+      const slots = asRecord(plugins.slots);
+      const slot = typeof slots.memory === "string" ? String(slots.memory).trim() : "";
+      if (!slot) {
+        this.api.logger.warn(
+          `clawmem: plugins.slots.memory is not set, so OpenClaw may keep the default memory plugin active. Set plugins.slots.memory to "${this.api.id}" and restart the gateway.`,
+        );
+        return;
+      }
+      if (slot !== this.api.id) {
+        this.api.logger.warn(
+          `clawmem: plugins.slots.memory is "${slot}", so ClawMem is not the selected memory plugin. Set plugins.slots.memory to "${this.api.id}" and restart the gateway.`,
+        );
+      }
+    } catch (error) {
+      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> {
     const root = this.api.runtime.config.loadConfig();
     const plugins = root.plugins;
@@ -260,6 +526,57 @@ class ClawMemService {
       },
     });
   }
+  private async runRequestMaintenance(agentId: string): Promise<void> {
+    const sessions = Object.values(this.state.sessions)
+      .filter((session) => normalizeAgentId(session.agentId) === agentId)
+      .sort((a, b) => Date.parse(b.updatedAt ?? b.createdAt ?? "") - Date.parse(a.updatedAt ?? a.createdAt ?? ""))
+      .slice(0, 8);
+    if (sessions.length === 0) return;
+    const { conv, mem } = this.getServices(agentId);
+    let changed = false;
+    let workDone = 0;
+    for (const session of sessions) {
+      if (workDone >= 3) break;
+      const snap = await conv.loadSnapshot(session, []);
+      if (!conv.shouldMirror(session.sessionId, snap.messages) || snap.messages.length === 0) continue;
+      if (!session.issueNumber) {
+        await conv.ensureIssue(session, snap);
+        changed = true;
+      }
+      if (session.summaryStatus === "pending") {
+        try {
+          const result = await conv.generateSummaryAndTitle(session, snap);
+          await conv.syncLabels(session, snap, true);
+          await conv.syncBody(session, snap, result.summary, true, result.title);
+          session.summaryStatus = "complete";
+          if (result.title?.trim()) {
+            session.issueTitle = result.title.trim();
+            session.titleSource = "llm";
+          }
+          this.maybeAutoNameRepo(agentId, result.summary, result.title);
+          changed = true;
+          workDone++;
+        } catch (error) {
+          this.warn(`request-scoped summary sync for ${session.sessionId}`, error);
+        }
+      }
+      if (session.titleSource !== "llm" && snap.messages.length >= 2) {
+        await conv.syncTitle(session, snap);
+        changed = true;
+        workDone++;
+      }
+      if (snap.messages.length >= 2 && snap.messages.length > (session.lastMemorySyncCount ?? 0)) {
+        const ok = await mem.syncFromConversation(session, snap);
+        if (ok) {
+          session.lastMemorySyncCount = snap.messages.length;
+          changed = true;
+        }
+        workDone++;
+      }
+    }
+    if (changed) await this.persistState();
+  }
+
   private getServices(agentId?: string): { conv: ConversationMirror; mem: MemoryStore } {
     const client = new GitHubIssueClient(resolveAgentRoute(this.config, agentId), this.api.logger);
     return {
@@ -267,9 +584,55 @@ class ClawMemService {
       mem: new MemoryStore(client, this.api, this.config),
     };
   }
+  private resolveToolAgentId(agentId: unknown): string {
+    return normalizeAgentId(typeof agentId === "string" && agentId.trim() ? agentId : process.env.OPENCLAW_AGENT_ID);
+  }
+  /**
+   * 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)}`); }
 }
 
 function asRecord(v: unknown): Record<string, unknown> { return v && typeof v === "object" ? (v as Record<string, unknown>) : {}; }
+function toolText(text: string): { content: Array<{ type: "text"; text: string }> } {
+  return { content: [{ type: "text", text }] };
+}
+function renderMemoryLine(memory: { memoryId: string; title?: string; detail: string; kind?: string; topics?: string[]; status: "active" | "stale" }): string {
+  const schema = [memory.kind ? `kind:${memory.kind}` : "", ...(memory.topics ?? []).map((topic) => `topic:${topic}`)].filter(Boolean).join(", ");
+  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 {
+  const lines = [
+    `Memory ID: ${memory.memoryId}`,
+    ...(typeof memory.issueNumber === "number" ? [`Issue Number: ${memory.issueNumber}`] : []),
+    `Status: ${memory.status}`,
+    `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}`,
+  ];
+  return lines.join("\n");
+}
 
 export function createClawMemPlugin(api: OpenClawPluginApi): void { new ClawMemService(api).register(); }

package/src/state.ts

@@ -42,9 +42,17 @@ function sanitizeState(value: unknown): PluginState {
     raw.sessions && typeof raw.sessions === "object"
       ? (raw.sessions as Record<string, unknown>)
       : {};
+  const migrations: Record<string, string> = {};
+  if (raw.migrations && typeof raw.migrations === "object") {
+    for (const [k, v] of Object.entries(raw.migrations as Record<string, unknown>)) {
+      const s = readString(v);
+      if (s) migrations[k] = s;
+    }
+  }
   const out: PluginState = {
     version: 2,
     sessions: {},
+    ...(Object.keys(migrations).length > 0 ? { migrations } : {}),
   };
   for (const [storedKey, sessionValue] of Object.entries(sessions)) {
     if (!sessionValue || typeof sessionValue !== "object" || !storedKey.trim()) {
@@ -63,8 +71,11 @@ function sanitizeState(value: unknown): PluginState {
       agentId,
       issueNumber: readNumber(rawSession.issueNumber),
       issueTitle: readString(rawSession.issueTitle),
+      titleSource: readEnum(rawSession.titleSource, ["placeholder", "llm"]),
       lastMirroredCount: readNumber(rawSession.lastMirroredCount) ?? 0,
       turnCount: readNumber(rawSession.turnCount) ?? 0,
+      lastMemorySyncCount: readNumber(rawSession.lastMemorySyncCount),
+      summaryStatus: readEnum(rawSession.summaryStatus, ["pending", "complete"]),
       finalizedAt: readString(rawSession.finalizedAt),
       lastSummaryHash: readString(rawSession.lastSummaryHash),
       lastTurnHash: readString(rawSession.lastTurnHash),
@@ -83,6 +94,11 @@ function readString(value: unknown): string | undefined {
   return trimmed ? trimmed : undefined;
 }
 
+function readEnum<T extends string>(value: unknown, allowed: T[]): T | undefined {
+  const s = readString(value);
+  return s && (allowed as string[]).includes(s) ? (s as T) : undefined;
+}
+
 function readNumber(value: unknown): number | undefined {
   if (typeof value !== "number" || !Number.isFinite(value)) {
     return undefined;

package/src/types.ts

@@ -26,16 +26,26 @@ export type ClawMemResolvedRoute = {
 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;
-  issueNumber?: number; issueTitle?: string;
+  issueNumber?: number; issueTitle?: string; titleSource?: "placeholder" | "llm";
   lastMirroredCount: number; turnCount: number; lastAssistantText?: string;
+  lastMemorySyncCount?: number;
+  summaryStatus?: "pending" | "complete";
   finalizedAt?: string; lastSummaryHash?: string; lastTurnHash?: string;
   createdAt?: string; updatedAt?: string;
 };
-export type PluginState = { version: 2; sessions: Record<string, SessionMirrorState> };
+export type PluginState = { version: 2; sessions: Record<string, SessionMirrorState>; migrations?: Record<string, string> };
 export type NormalizedMessage = { role: string; text: string; toolName?: string; timestamp?: string; stopReason?: string };
 export type TranscriptSnapshot = { sessionId?: string; messages: NormalizedMessage[] };
+export type MemoryDraft = { detail: string; kind?: string; topics?: string[] };
+export type MemorySchema = { kinds: string[]; topics: string[] };
+export type MemoryListOptions = {
+  status?: "active" | "stale" | "all";
+  kind?: string;
+  topic?: string;
+  limit?: number;
+};
 export type ParsedMemoryIssue = {
   issueNumber: number; title: string; memoryId: string; memoryHash?: string;
   sessionId: string; date: string; detail: string;
-  topics?: string[]; status: "active" | "stale";
+  kind?: string; topics?: string[]; status: "active" | "stale";
 };