@clawmem-ai/clawmem 0.1.16 → 0.1.18

package/src/service.ts

@@ -1,15 +1,15 @@
 // Thin orchestrator: wires conversation mirroring, memory store, and plugin lifecycle.
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
+import type { MemoryPluginCapability, OpenClawPluginApi } from "openclaw/plugin-sdk/core";
 import { hasDefaultRepo, isAgentConfigured, resolveAgentRoute, resolvePluginConfig } from "./config.js";
 import { filterDirectCollaborators, listRepoAccessTeams, resolveOrgInvitationRole } from "./collaboration.js";
 import { ConversationMirror } from "./conversation.js";
 import { GitHubIssueClient } from "./github-client.js";
 import { KeyedAsyncQueue } from "./keyed-async-queue.js";
-import { MemoryStore, mergeMemoryCandidates } from "./memory.js";
+import { MemoryStore } from "./memory.js";
 import { sanitizeRecallQueryInput } from "./recall-sanitize.js";
 import { loadState, resolveStatePath, saveState } from "./state.js";
 import { readTranscriptSnapshot } from "./transcript.js";
-import type { BootstrapIdentityResponse, ClawMemPluginConfig, ClawMemResolvedRoute, PluginState, SessionDerivedState, SessionMirrorState, TranscriptSnapshot } from "./types.js";
+import type { BootstrapIdentityResponse, ClawMemPluginConfig, ClawMemResolvedRoute, MemoryCandidate, PluginState, SessionDerivedState, SessionMirrorState, TranscriptSnapshot } from "./types.js";
 import { buildAgentBootstrapRegistration, inferAgentIdFromTranscriptPath, normalizeAgentId, sessionScopeKey } from "./utils.js";
 import { getOpenClawAgentIdFromEnv, getOpenClawHostVersionFromEnv } from "./runtime-env.js";
 
@@ -17,25 +17,37 @@ type TurnPayload = { sessionId?: string; sessionKey?: string; agentId?: string;
 type FinalizePayload = { sessionId?: string; sessionKey?: string; sessionFile?: string; agentId?: string; reason?: string; messages?: unknown[] };
 type CollaborationPermission = "read" | "write" | "admin";
 type CollaborationTeamRole = "member" | "maintainer";
+type MemoryPromptBuilder = NonNullable<MemoryPluginCapability["promptBuilder"]>;
+type MemoryPromptBuilderParams = Parameters<MemoryPromptBuilder>[0];
+type PromptBuildInjection = { prependContext?: string; prependSystemContext?: string };
 
-const DERIVED_WORK_RECOVERY_DELAYS_MS = [5000, 30000, 120000] as const;
 const MODERN_PROMPT_HOOK_MIN_HOST_VERSION = "2026.3.7";
+const MEMORY_PROMPT_REGISTRATION_MIN_HOST_VERSION = "2026.3.22";
+const CLAWMEM_PROMPT_GUIDANCE_TOOL_NAMES = [
+  "memory_repos",
+  "memory_repo_create",
+  "memory_list",
+  "memory_labels",
+  "memory_recall",
+  "memory_get",
+  "memory_store",
+  "memory_update",
+  "memory_forget",
+] as const;
 type PromptHookMode = "modern" | "legacy";
 
 class ClawMemService {
   private readonly config: ClawMemPluginConfig;
   private readonly ioQueue = new KeyedAsyncQueue();
-  private readonly deriveQueue = new KeyedAsyncQueue();
   private readonly repoWriteQueue = new KeyedAsyncQueue();
   private readonly stateQueue = new KeyedAsyncQueue();
   private readonly pending = new Set<Promise<unknown>>();
-  private readonly syncTimers = new Map<string, ReturnType<typeof setTimeout>>();
-  private readonly recoveryTimers = new Map<string, ReturnType<typeof setTimeout>>();
   private statePath = "";
-  private state: PluginState = { version: 3, sessions: {} };
+  private state: PluginState = { version: 4, sessions: {} };
   private unsubTranscript?: () => void;
   private loadPromise: Promise<void> | null = null;
   private readonly configPromises = new Map<string, Promise<boolean>>();
+  private injectPromptGuidanceViaSystemContext = false;
 
   constructor(private readonly api: OpenClawPluginApi) {
     this.config = resolvePluginConfig(api);
@@ -43,14 +55,33 @@ class ClawMemService {
 
   register(): void {
     const promptHookMode = resolvePromptHookMode(this.api);
+    this.registerMemoryPromptGuidance(promptHookMode);
     if (promptHookMode === "modern") {
       this.api.on("before_prompt_build", async (ev, ctx) => this.handleBeforePromptBuild(ev, ctx.agentId));
     } else {
       this.api.on("before_agent_start", async (ev, ctx) => this.handleBeforeAgentStart(ev, 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.api.on("agent_end", async (ev, ctx) => {
+      try {
+        await this.handleAgentEnd({ sessionId: ctx.sessionId, sessionKey: ctx.sessionKey, agentId: ctx.agentId, messages: ev.messages });
+      } catch (error) {
+        this.warn("turn sync", error);
+      }
+    });
+    this.api.on("before_reset", async (ev, ctx) => {
+      try {
+        await this.handleFinalize({ sessionId: ctx.sessionId, sessionKey: ctx.sessionKey, sessionFile: ev.sessionFile, agentId: ctx.agentId, reason: ev.reason, messages: ev.messages });
+      } catch (error) {
+        this.warn("finalize", error);
+      }
+    });
+    this.api.on("session_end", async (ev, ctx) => {
+      try {
+        await this.handleFinalize({ sessionId: ev.sessionId ?? ctx.sessionId, sessionKey: ev.sessionKey ?? ctx.sessionKey, agentId: ctx.agentId, reason: "session_end" });
+      } catch (error) {
+        this.warn("finalize", error);
+      }
+    });
     this.registerTools();
 
     this.api.registerService({
@@ -62,7 +93,6 @@ class ClawMemService {
         this.unsubTranscript = this.api.runtime.events.onSessionTranscriptUpdate((u) => {
           void this.track(this.handleTranscript(u.sessionFile)).catch((e) => this.warn("transcript update", e));
         });
-        this.recoverDerivedWorkOnStart();
         const configuredCount = Object.keys(this.config.agents).filter((agentId) => {
           const route = resolveAgentRoute(this.config, agentId);
           return isAgentConfigured(route) && hasDefaultRepo(route);
@@ -76,15 +106,74 @@ class ClawMemService {
       },
       stop: async () => {
         this.unsubTranscript?.();
-        for (const t of this.syncTimers.values()) clearTimeout(t);
-        this.syncTimers.clear();
-        for (const t of this.recoveryTimers.values()) clearTimeout(t);
-        this.recoveryTimers.clear();
         await Promise.allSettled([...this.pending]);
       },
     });
   }
 
+  private registerMemoryPromptGuidance(promptHookMode: PromptHookMode): void {
+    if (!this.isSelectedMemoryPlugin()) return;
+
+    const api = this.api as OpenClawPluginApi & {
+      registerMemoryCapability?: OpenClawPluginApi["registerMemoryCapability"];
+      registerMemoryPromptSection?: OpenClawPluginApi["registerMemoryPromptSection"];
+    };
+
+    if (typeof api.registerMemoryCapability === "function") {
+      api.registerMemoryCapability({ promptBuilder: buildClawMemPromptSection });
+      return;
+    }
+
+    if (typeof api.registerMemoryPromptSection === "function") {
+      api.registerMemoryPromptSection(buildClawMemPromptSection);
+      return;
+    }
+
+    const hostVersion = resolveOpenClawHostVersion(this.api);
+    const comparison = hostVersion ? compareOpenClawVersions(hostVersion, MEMORY_PROMPT_REGISTRATION_MIN_HOST_VERSION) : null;
+    if (promptHookMode === "modern") {
+      this.injectPromptGuidanceViaSystemContext = true;
+      if (comparison !== null && comparison < 0) {
+        this.api.logger.info?.(
+          `clawmem: OpenClaw ${hostVersion} predates memory prompt registration (requires ${MEMORY_PROMPT_REGISTRATION_MIN_HOST_VERSION}+); falling back to before_prompt_build prependSystemContext for always-on prompt guidance`,
+        );
+        return;
+      }
+
+      this.api.logger.warn?.(
+        hostVersion
+          ? `clawmem: OpenClaw ${hostVersion} does not expose memory prompt registration; falling back to before_prompt_build prependSystemContext for always-on prompt guidance`
+          : "clawmem: host does not expose memory prompt registration; falling back to before_prompt_build prependSystemContext for always-on prompt guidance",
+      );
+      return;
+    }
+
+    if (comparison !== null && comparison < 0) {
+      this.api.logger.info?.(
+        `clawmem: OpenClaw ${hostVersion} predates memory prompt registration and prompt-level system-context fallback; always-on prompt guidance is unavailable on this host`,
+      );
+      return;
+    }
+
+    this.api.logger.warn?.(
+      hostVersion
+        ? `clawmem: OpenClaw ${hostVersion} does not expose memory prompt registration; always-on prompt guidance is disabled`
+        : "clawmem: host does not expose memory prompt registration; always-on prompt guidance is disabled",
+    );
+  }
+
+  private isSelectedMemoryPlugin(): boolean {
+    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() : "";
+      return slot === this.api.id;
+    } catch {
+      return false;
+    }
+  }
+
   private registerTools(): void {
     this.api.registerTool({
       name: "memory_repos",
@@ -430,6 +519,7 @@ class ClawMemService {
         return toolText(`Marked memory [${forgotten.memoryId}] stale in ${resolved.route.repo}: ${forgotten.detail}`);
       },
     });
+
     this.registerCollaborationTools();
   }
 
@@ -507,6 +597,147 @@ class ClawMemService {
       },
     });
 
+    this.api.registerTool({
+      name: "collaboration_org_members",
+      description: "List visible members in an organization, optionally filtering to admins only.",
+      required: true,
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          org: { type: "string", minLength: 1, description: "Organization login." },
+          role: { type: "string", enum: ["admin"], description: "Optional role filter. Use admin to show org owners only." },
+          agentId: { type: "string", minLength: 1, description: "Optional agent identity override. Defaults to the current agent when available." },
+        },
+        required: ["org"],
+      },
+      execute: async (_id: string, params: unknown) => {
+        const p = asRecord(params);
+        const org = typeof p.org === "string" ? p.org.trim() : "";
+        if (!org) return toolText("org is empty.");
+        const role = p.role === "admin" ? "admin" : undefined;
+        const agentId = this.resolveToolAgentId(p.agentId);
+        const resolved = await this.requireToolIdentity(agentId);
+        if ("error" in resolved) return toolText(resolved.error);
+        try {
+          const members = await resolved.client.listOrgMembers(org, role);
+          if (members.length === 0) {
+            return toolText(role === "admin"
+              ? `No org admins are visible in "${org}".`
+              : `No org members are visible in "${org}".`);
+          }
+          return toolText([
+            role === "admin" ? `Org admins in "${org}":` : `Org members in "${org}":`,
+            ...members.map((member) => `- ${renderCollaboratorLine(member)}`),
+          ].join("\n"));
+        } catch (error) {
+          return toolText(`Unable to list members for org "${org}": ${String(error)}`);
+        }
+      },
+    });
+
+    this.api.registerTool({
+      name: "collaboration_org_membership",
+      description: "Inspect one user's organization membership state, including active versus pending invitation state.",
+      required: true,
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          org: { type: "string", minLength: 1, description: "Organization login." },
+          username: { type: "string", minLength: 1, description: "Username to inspect." },
+          agentId: { type: "string", minLength: 1, description: "Optional agent identity override. Defaults to the current agent when available." },
+        },
+        required: ["org", "username"],
+      },
+      execute: async (_id: string, params: unknown) => {
+        const p = asRecord(params);
+        const org = typeof p.org === "string" ? p.org.trim() : "";
+        const username = typeof p.username === "string" ? p.username.trim() : "";
+        if (!org || !username) return toolText("org and username are required.");
+        const agentId = this.resolveToolAgentId(p.agentId);
+        const resolved = await this.requireToolIdentity(agentId);
+        if ("error" in resolved) return toolText(resolved.error);
+        try {
+          const membership = await resolved.client.getOrgMembership(org, username);
+          return toolText(`Organization membership in "${org}":\n- ${renderOrganizationMembershipLine(membership)}`);
+        } catch (error) {
+          if (isHttpStatusError(error, 404)) {
+            return toolText(`No active or pending organization membership was found for ${username} in "${org}".`);
+          }
+          return toolText(`Unable to inspect organization membership for ${username} in "${org}": ${String(error)}`);
+        }
+      },
+    });
+
+    this.api.registerTool({
+      name: "collaboration_org_member_remove",
+      description: "Remove an active organization member. Requires confirmed=true after explicit user approval.",
+      required: true,
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          org: { type: "string", minLength: 1, description: "Organization login." },
+          username: { type: "string", minLength: 1, description: "Active org member to remove." },
+          confirmed: { type: "boolean", description: "Must be true after the user approves the exact write action." },
+          agentId: { type: "string", minLength: 1, description: "Optional agent identity override. Defaults to the current agent when available." },
+        },
+        required: ["org", "username"],
+      },
+      execute: async (_id: string, params: unknown) => {
+        const p = asRecord(params);
+        const blocked = this.requireMutationConfirmation(p, "remove an organization member");
+        if (blocked) return toolText(blocked);
+        const org = typeof p.org === "string" ? p.org.trim() : "";
+        const username = typeof p.username === "string" ? p.username.trim() : "";
+        if (!org || !username) return toolText("org and username are required.");
+        const agentId = this.resolveToolAgentId(p.agentId);
+        const resolved = await this.requireToolIdentity(agentId);
+        if ("error" in resolved) return toolText(resolved.error);
+        try {
+          await resolved.client.removeOrgMember(org, username);
+          return toolText(`Removed active organization member ${username} from "${org}". Server-side org-scoped team memberships were cleaned up as part of the removal.`);
+        } catch (error) {
+          return toolText(`Unable to remove ${username} from org "${org}": ${String(error)}`);
+        }
+      },
+    });
+
+    this.api.registerTool({
+      name: "collaboration_org_membership_remove",
+      description: "Remove an active organization membership or revoke a pending org invitation for that user. Requires confirmed=true after explicit user approval.",
+      required: true,
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          org: { type: "string", minLength: 1, description: "Organization login." },
+          username: { type: "string", minLength: 1, description: "Username whose active membership or pending invite should be removed." },
+          confirmed: { type: "boolean", description: "Must be true after the user approves the exact write action." },
+          agentId: { type: "string", minLength: 1, description: "Optional agent identity override. Defaults to the current agent when available." },
+        },
+        required: ["org", "username"],
+      },
+      execute: async (_id: string, params: unknown) => {
+        const p = asRecord(params);
+        const blocked = this.requireMutationConfirmation(p, "remove an organization membership");
+        if (blocked) return toolText(blocked);
+        const org = typeof p.org === "string" ? p.org.trim() : "";
+        const username = typeof p.username === "string" ? p.username.trim() : "";
+        if (!org || !username) return toolText("org and username are required.");
+        const agentId = this.resolveToolAgentId(p.agentId);
+        const resolved = await this.requireToolIdentity(agentId);
+        if ("error" in resolved) return toolText(resolved.error);
+        try {
+          await resolved.client.removeOrgMembership(org, username);
+          return toolText(`Removed organization membership state for ${username} in "${org}". This deletes an active membership or revokes a pending org invitation, depending on current state.`);
+        } catch (error) {
+          return toolText(`Unable to remove organization membership state for ${username} in "${org}": ${String(error)}`);
+        }
+      },
+    });
+
     this.api.registerTool({
       name: "collaboration_teams",
       description: "List teams in an organization before granting repo access or managing membership.",
@@ -540,6 +771,37 @@ class ClawMemService {
       },
     });
 
+    this.api.registerTool({
+      name: "collaboration_team",
+      description: "Inspect one organization team by slug.",
+      required: true,
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          org: { type: "string", minLength: 1, description: "Organization login." },
+          teamSlug: { type: "string", minLength: 1, description: "Team slug." },
+          agentId: { type: "string", minLength: 1, description: "Optional agent identity override. Defaults to the current agent when available." },
+        },
+        required: ["org", "teamSlug"],
+      },
+      execute: async (_id: string, params: unknown) => {
+        const p = asRecord(params);
+        const org = typeof p.org === "string" ? p.org.trim() : "";
+        const teamSlug = typeof p.teamSlug === "string" ? p.teamSlug.trim() : "";
+        if (!org || !teamSlug) return toolText("org and teamSlug are required.");
+        const agentId = this.resolveToolAgentId(p.agentId);
+        const resolved = await this.requireToolIdentity(agentId);
+        if ("error" in resolved) return toolText(resolved.error);
+        try {
+          const team = await resolved.client.getTeam(org, teamSlug);
+          return toolText(`Team in "${org}":\n- ${renderTeamLine(team)}`);
+        } catch (error) {
+          return toolText(`Unable to inspect team ${org}/${teamSlug}: ${String(error)}`);
+        }
+      },
+    });
+
     this.api.registerTool({
       name: "collaboration_team_create",
       description: "Create a team inside an organization. Requires confirmed=true after explicit user approval.",
@@ -581,6 +843,122 @@ class ClawMemService {
       },
     });
 
+    this.api.registerTool({
+      name: "collaboration_team_update",
+      description: "Update a team's name, description, or privacy. Requires confirmed=true after explicit user approval.",
+      required: true,
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          org: { type: "string", minLength: 1, description: "Organization login." },
+          teamSlug: { type: "string", minLength: 1, description: "Current team slug." },
+          name: { type: "string", minLength: 1, description: "Optional new team display name." },
+          description: { type: "string", minLength: 1, description: "Optional new team description." },
+          privacy: { type: "string", enum: ["closed", "secret"], description: "Optional team privacy." },
+          confirmed: { type: "boolean", description: "Must be true after the user approves the exact write action." },
+          agentId: { type: "string", minLength: 1, description: "Optional agent identity override. Defaults to the current agent when available." },
+        },
+        required: ["org", "teamSlug"],
+      },
+      execute: async (_id: string, params: unknown) => {
+        const p = asRecord(params);
+        const blocked = this.requireMutationConfirmation(p, "update a team");
+        if (blocked) return toolText(blocked);
+        const org = typeof p.org === "string" ? p.org.trim() : "";
+        const teamSlug = typeof p.teamSlug === "string" ? p.teamSlug.trim() : "";
+        if (!org || !teamSlug) return toolText("org and teamSlug are required.");
+        const name = typeof p.name === "string" && p.name.trim() ? p.name.trim() : undefined;
+        const description = typeof p.description === "string" && p.description.trim() ? p.description.trim() : undefined;
+        const privacy = p.privacy === "secret" ? "secret" : p.privacy === "closed" ? "closed" : undefined;
+        if (!name && !description && !privacy) {
+          return toolText("Provide at least one of name, description, or privacy when updating a team.");
+        }
+        const agentId = this.resolveToolAgentId(p.agentId);
+        const resolved = await this.requireToolIdentity(agentId);
+        if ("error" in resolved) return toolText(resolved.error);
+        try {
+          const updated = await resolved.client.updateTeam(org, teamSlug, {
+            ...(name ? { name } : {}),
+            ...(description ? { description } : {}),
+            ...(privacy ? { privacy } : {}),
+          });
+          return toolText(`Updated team in "${org}": ${renderTeamLine(updated)}.`);
+        } catch (error) {
+          return toolText(`Unable to update team ${org}/${teamSlug}: ${String(error)}`);
+        }
+      },
+    });
+
+    this.api.registerTool({
+      name: "collaboration_team_delete",
+      description: "Delete a team. Requires confirmed=true after explicit user approval.",
+      required: true,
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          org: { type: "string", minLength: 1, description: "Organization login." },
+          teamSlug: { type: "string", minLength: 1, description: "Team slug." },
+          confirmed: { type: "boolean", description: "Must be true after the user approves the exact write action." },
+          agentId: { type: "string", minLength: 1, description: "Optional agent identity override. Defaults to the current agent when available." },
+        },
+        required: ["org", "teamSlug"],
+      },
+      execute: async (_id: string, params: unknown) => {
+        const p = asRecord(params);
+        const blocked = this.requireMutationConfirmation(p, "delete a team");
+        if (blocked) return toolText(blocked);
+        const org = typeof p.org === "string" ? p.org.trim() : "";
+        const teamSlug = typeof p.teamSlug === "string" ? p.teamSlug.trim() : "";
+        if (!org || !teamSlug) return toolText("org and teamSlug are required.");
+        const agentId = this.resolveToolAgentId(p.agentId);
+        const resolved = await this.requireToolIdentity(agentId);
+        if ("error" in resolved) return toolText(resolved.error);
+        try {
+          await resolved.client.deleteTeam(org, teamSlug);
+          return toolText(`Deleted team ${org}/${teamSlug}.`);
+        } catch (error) {
+          return toolText(`Unable to delete team ${org}/${teamSlug}: ${String(error)}`);
+        }
+      },
+    });
+
+    this.api.registerTool({
+      name: "collaboration_team_members",
+      description: "List members of an organization team.",
+      required: true,
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          org: { type: "string", minLength: 1, description: "Organization login." },
+          teamSlug: { type: "string", minLength: 1, description: "Team slug." },
+          agentId: { type: "string", minLength: 1, description: "Optional agent identity override. Defaults to the current agent when available." },
+        },
+        required: ["org", "teamSlug"],
+      },
+      execute: async (_id: string, params: unknown) => {
+        const p = asRecord(params);
+        const org = typeof p.org === "string" ? p.org.trim() : "";
+        const teamSlug = typeof p.teamSlug === "string" ? p.teamSlug.trim() : "";
+        if (!org || !teamSlug) return toolText("org and teamSlug are required.");
+        const agentId = this.resolveToolAgentId(p.agentId);
+        const resolved = await this.requireToolIdentity(agentId);
+        if ("error" in resolved) return toolText(resolved.error);
+        try {
+          const members = await resolved.client.listTeamMembers(org, teamSlug);
+          if (members.length === 0) return toolText(`No members found in ${org}/${teamSlug}.`);
+          return toolText([
+            `Members of ${org}/${teamSlug}:`,
+            ...members.map((member) => `- ${renderCollaboratorLine(member)}`),
+          ].join("\n"));
+        } catch (error) {
+          return toolText(`Unable to list members for ${org}/${teamSlug}: ${String(error)}`);
+        }
+      },
+    });
+
     this.api.registerTool({
       name: "collaboration_team_membership_set",
       description: "Add or update a user's membership in an organization team. Requires confirmed=true after explicit user approval.",
@@ -763,6 +1141,40 @@ class ClawMemService {
       },
     });
 
+    this.api.registerTool({
+      name: "collaboration_repo_transfer",
+      description: "Transfer a repository to a new owner, commonly used to move a personal memory repo into an existing org. Requires confirmed=true after explicit user approval.",
+      required: true,
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          repo: { type: "string", minLength: 3, description: "Optional source repo in owner/repo form. Defaults to the agent's defaultRepo." },
+          newOwner: { type: "string", minLength: 1, description: "Destination owner login, often an organization login." },
+          confirmed: { type: "boolean", description: "Must be true after the user approves the exact write action." },
+          agentId: { type: "string", minLength: 1, description: "Optional agent identity override. Defaults to the current agent when available." },
+        },
+        required: ["newOwner"],
+      },
+      execute: async (_id: string, params: unknown) => {
+        const p = asRecord(params);
+        const blocked = this.requireMutationConfirmation(p, "transfer a repository");
+        if (blocked) return toolText(blocked);
+        const newOwner = typeof p.newOwner === "string" ? p.newOwner.trim() : "";
+        if (!newOwner) return toolText("newOwner is empty.");
+        const agentId = this.resolveToolAgentId(p.agentId);
+        const target = await this.requireCollaborationRepo(agentId, p.repo);
+        if ("error" in target) return toolText(target.error);
+        try {
+          const transferred = await target.client.transferRepo(target.owner, target.repo, newOwner);
+          const nextFullName = repoSummaryFullName(transferred) || `${newOwner}/${target.repo}`;
+          return toolText(`Transferred ${target.fullName} to ${nextFullName}. If this repo was your configured defaultRepo, retarget future memory operations to ${nextFullName} explicitly until config is updated.`);
+        } catch (error) {
+          return toolText(`Unable to transfer ${target.fullName} to ${newOwner}: ${String(error)}`);
+        }
+      },
+    });
+
     this.api.registerTool({
       name: "collaboration_repo_collaborators",
       description: "List direct collaborators on a repo before changing repository-level access.",
@@ -1088,6 +1500,41 @@ class ClawMemService {
       },
     });
 
+    this.api.registerTool({
+      name: "collaboration_org_invitation_revoke",
+      description: "Revoke a pending organization invitation from the org side. Requires confirmed=true after explicit user approval.",
+      required: true,
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          org: { type: "string", minLength: 1, description: "Organization login." },
+          invitationId: { type: "integer", minimum: 1, description: "Pending organization invitation id." },
+          confirmed: { type: "boolean", description: "Must be true after the user approves the exact write action." },
+          agentId: { type: "string", minLength: 1, description: "Optional agent identity override. Defaults to the current agent when available." },
+        },
+        required: ["org", "invitationId"],
+      },
+      execute: async (_id: string, params: unknown) => {
+        const p = asRecord(params);
+        const blocked = this.requireMutationConfirmation(p, "revoke an organization invitation");
+        if (blocked) return toolText(blocked);
+        const org = typeof p.org === "string" ? p.org.trim() : "";
+        if (!org) return toolText("org is empty.");
+        const invitationId = this.resolvePositiveInteger(p.invitationId, "invitationId");
+        if ("error" in invitationId) return toolText(invitationId.error);
+        const agentId = this.resolveToolAgentId(p.agentId);
+        const resolved = await this.requireToolIdentity(agentId);
+        if ("error" in resolved) return toolText(resolved.error);
+        try {
+          await resolved.client.revokeOrgInvitation(org, invitationId.value);
+          return toolText(`Revoked organization invitation ${invitationId.value} in "${org}".`);
+        } catch (error) {
+          return toolText(`Unable to revoke organization invitation ${invitationId.value} in "${org}": ${String(error)}`);
+        }
+      },
+    });
+
     this.api.registerTool({
       name: "collaboration_user_org_invitations",
       description: "List pending organization invitations for the current ClawMem identity before concluding that no shared org access is available.",
@@ -1234,6 +1681,7 @@ class ClawMemService {
         additionalProperties: false,
         properties: {
           repo: { type: "string", minLength: 3, description: "Optional target repo in owner/repo form. Defaults to the agent's defaultRepo." },
+          username: { type: "string", minLength: 1, description: "Optional username to inspect for org-level base permission and membership state on org-owned repos." },
           agentId: { type: "string", minLength: 1, description: "Optional agent identity override. Defaults to the current agent when available." },
         },
       },
@@ -1246,7 +1694,10 @@ class ClawMemService {
         try {
           const lines = [`Repo access inspection for ${target.fullName}:`];
           const notes: string[] = [];
+          const username = typeof p.username === "string" ? p.username.trim() : "";
           let orgName: string | undefined;
+          let orgDefaultPermission: "none" | CollaborationPermission | undefined;
+          let orgContextAvailable = false;
 
           try {
             const repo = await target.client.getRepo(target.owner, target.repo);
@@ -1259,12 +1710,49 @@ class ClawMemService {
           }
 
           try {
-            const org = await target.client.getOrg(orgName);
-            lines.push(`- Org default repository permission: ${org.default_repository_permission?.trim() || "unknown"}`);
+            const ownerOrg = orgName || target.owner;
+            const org = await target.client.getOrg(ownerOrg);
+            orgContextAvailable = true;
+            orgDefaultPermission = normalizePermissionAlias(org.default_repository_permission);
+            lines.push(`- Org default repository permission: ${orgDefaultPermission || "unknown"}`);
           } catch (error) {
             notes.push(`Org metadata unavailable for "${orgName}": ${String(error)}`);
           }
 
+          if (username) {
+            lines.push("");
+            lines.push(`Org membership for "${username}" in "${orgName}":`);
+            if (!orgName || !orgContextAvailable) {
+              lines.push("- Not applicable because the owner org could not be resolved.");
+            } else {
+              try {
+                const membership = await target.client.getOrgMembership(orgName, username);
+                lines.push(`- ${renderOrganizationMembershipLine(membership)}`);
+                if (membership.state === "active") {
+                  if (orgDefaultPermission && orgDefaultPermission !== "none") {
+                    lines.push(`- Org base repo access is active via default permission "${orgDefaultPermission}".`);
+                    notes.push(`Because ${username} is an active org member and "${orgName}" default repository permission is ${orgDefaultPermission}, removing direct collaborators or team grants alone may not remove repo access.`);
+                  } else {
+                    lines.push("- No org base repo access is visible because the org default permission is none.");
+                  }
+                } else {
+                  lines.push("- Org base repo access is not active yet because the org membership is still pending.");
+                }
+              } catch (error) {
+                if (isHttpStatusError(error, 404)) {
+                  lines.push("- No active or pending org membership was found.");
+                  if (orgDefaultPermission && orgDefaultPermission !== "none") {
+                    lines.push("- Org base repo access does not apply unless the user becomes an org member.");
+                  }
+                } else {
+                  notes.push(`Org membership lookup failed for "${username}" in "${orgName}": ${String(error)}`);
+                }
+              }
+            }
+          } else if (orgDefaultPermission && orgDefaultPermission !== "none") {
+            notes.push(`Any active org member can still inherit ${orgDefaultPermission} access from "${orgName}" even after direct collaborator or team grants are removed.`);
+          }
+
           try {
             const collaborators = filterDirectCollaborators(await target.client.listRepoCollaborators(target.owner, target.repo), target.owner);
             lines.push("");
@@ -1299,7 +1787,8 @@ class ClawMemService {
           }
 
           try {
-            const outside = await target.client.listOrgOutsideCollaborators(orgName);
+            const ownerOrg = orgName || target.owner;
+            const outside = await target.client.listOrgOutsideCollaborators(ownerOrg);
             lines.push("");
             lines.push(`Outside collaborators in owner org "${orgName}":`);
             if (outside.length === 0) lines.push("- None visible");
@@ -1321,9 +1810,17 @@ class ClawMemService {
     });
   }
 
-  private async handleBeforePromptBuild(event: unknown, agentId?: string): Promise<{ prependSystemContext: string } | void> {
+  private async handleBeforePromptBuild(event: unknown, agentId?: string): Promise<PromptBuildInjection | void> {
     const context = await this.collectAutoRecallContext(event, agentId);
-    return context ? { prependSystemContext: context } : undefined;
+    const systemContext = this.injectPromptGuidanceViaSystemContext ? buildFallbackPromptGuidanceText(event) : undefined;
+    // Auto-recall is per-turn dynamic context, so keep it out of the system prompt.
+    // OpenClaw documents dynamic context on `prependContext`: https://github.com/maweibin/openclaw/blob/d9a2869ad69db9449336a2e2846bd9de0e647ac6/docs/concepts/agent-loop.md?plain=1#L85
+    // Changing the system prompt can defeat provider prefix caching.
+    if (!context && !systemContext) return undefined;
+    return {
+      ...(systemContext ? { prependSystemContext: systemContext } : {}),
+      ...(context ? { prependContext: context } : {}),
+    };
   }
 
   private async handleBeforeAgentStart(event: unknown, agentId?: string): Promise<{ prependContext: string } | void> {
@@ -1331,6 +1828,16 @@ class ClawMemService {
     return context ? { prependContext: context } : undefined;
   }
 
+  private async handleAgentEnd(payload: TurnPayload): Promise<void> {
+    if (!payload.sessionId) return;
+    await this.enqueueSessionIo(sessionScopeKey(payload.sessionId, payload.agentId), () => this.syncTurn(payload));
+  }
+
+  private async handleFinalize(payload: FinalizePayload): Promise<void> {
+    if (!payload.sessionId) return;
+    await this.enqueueSessionIo(sessionScopeKey(payload.sessionId, payload.agentId), () => this.finalize(payload));
+  }
+
   private async collectAutoRecallContext(event: unknown, agentId?: string): Promise<string | undefined> {
     const routeAgentId = normalizeAgentId(agentId);
     if (!(await this.ensureDefaultRepoConfigured(routeAgentId))) return undefined;
@@ -1369,26 +1876,13 @@ class ClawMemService {
     });
   }
 
-  private scheduleTurn(p: TurnPayload): void {
-    if (!p.sessionId) return;
-    const scopeKey = sessionScopeKey(p.sessionId, p.agentId);
-    const prev = this.syncTimers.get(scopeKey);
-    if (prev) clearTimeout(prev);
-    const timer = setTimeout(() => {
-      this.syncTimers.delete(scopeKey);
-      void this.track(this.enqueueSessionIo(scopeKey, () => this.syncTurn(p))).catch((e) => this.warn("turn sync", e));
-    }, this.config.turnCommentDelayMs);
-    timer.unref?.();
-    this.syncTimers.set(scopeKey, timer);
-  }
-
   private async syncTurn(p: TurnPayload): Promise<void> {
     if (!p.sessionId) return;
     const agentId = normalizeAgentId(p.agentId);
-    const scopeKey = sessionScopeKey(p.sessionId, agentId);
     if (!(await this.ensureDefaultRepoConfigured(agentId))) return;
     const { conv } = this.getServices(agentId);
     const s = this.getOrCreate(p.sessionId, agentId);
+    if (s.finalizedAt) return;
     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; }
@@ -1396,43 +1890,183 @@ class ClawMemService {
     await conv.syncLabels(s, snap, false);
     const next = snap.messages.slice(s.lastMirroredCount);
     if (next.length > 0) { const n = await conv.appendComments(s.issueNumber!, next); s.lastMirroredCount += n; s.turnCount += n; }
-    this.markPostMirrorTasks(s);
     await this.persistState();
-    this.kickDerivedWork(scopeKey, agentId, "turn");
-  }
-
-  private enqueueFinalize(p: FinalizePayload): void {
-    if (!p.sessionId) return;
-    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.enqueueSessionIo(scopeKey, () => this.finalize(p))).catch((e) => this.warn("finalize", e));
   }
 
   private async finalize(p: FinalizePayload): Promise<void> {
     if (!p.sessionId) return;
     const agentId = normalizeAgentId(p.agentId);
-    const scopeKey = sessionScopeKey(p.sessionId, agentId);
     if (!(await this.ensureDefaultRepoConfigured(agentId))) return;
-    const { conv } = this.getServices(agentId);
+    const { conv, mem, route } = 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 = 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 conv.ensureIssue(s, snap);
-    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; }
-    await conv.syncLabels(s, snap, true);
-    await conv.syncBody(s, snap, "pending", true);
-    if (allOk) s.finalizedAt = new Date().toISOString();
-    this.markPostMirrorTasks(s);
-    this.markSummaryPending(s);
+    await this.captureSessionFinalState(s, snap, conv, mem, route, { markFinalized: true, reason: "finalize" });
+  }
+
+  private async captureSessionFinalState(
+    session: SessionMirrorState,
+    snapshot: TranscriptSnapshot,
+    conv: ConversationMirror,
+    mem: MemoryStore,
+    route: ClawMemResolvedRoute,
+    options: { markFinalized: boolean; reason: string },
+  ): Promise<void> {
+    await conv.ensureIssue(session, snapshot);
+    const next = snapshot.messages.slice(session.lastMirroredCount);
+    if (next.length > 0) {
+      const n = await conv.appendComments(session.issueNumber!, next);
+      session.lastMirroredCount += n;
+      session.turnCount += n;
+    }
+
+    const derived = this.ensureDerived(session);
+    let summaryText = derived.summary.text?.trim() || "pending";
+    let titleOverride = derived.summary.title?.trim() || session.issueTitle;
+    let generatedTitle = Boolean(derived.summary.title?.trim());
+    const targetCursor = snapshot.messages.length;
+    const meaningfulTranscript = snapshot.messages.filter((message) => message.text.trim()).length >= 2;
+
+    if (meaningfulTranscript) {
+      try {
+        const artifacts = await this.resolveFinalArtifacts(session, snapshot, conv, mem);
+        summaryText = artifacts.summary;
+        if (artifacts.title?.trim()) {
+          titleOverride = artifacts.title.trim();
+          generatedTitle = true;
+        }
+        const storedCount = await this.applyFinalMemoryCandidates(session, mem, route, targetCursor, artifacts.candidates);
+        if (storedCount > 0) {
+          this.api.logger.info?.(
+            `clawmem: ${options.reason} stored ${storedCount} memor${storedCount === 1 ? "y" : "ies"} for ${session.sessionId}`,
+          );
+        }
+      } catch (error) {
+        derived.summary.status = "error";
+        derived.summary.lastError = String(error);
+        derived.summary.updatedAt = new Date().toISOString();
+        derived.memory.status = "error";
+        derived.memory.lastError = String(error);
+        derived.memory.updatedAt = new Date().toISOString();
+        this.warn(`${options.reason} derive for ${session.sessionId}`, error);
+      }
+    } else {
+      derived.summary.status = "complete";
+      derived.summary.basedOnCursor = targetCursor;
+      derived.summary.lastError = undefined;
+      derived.summary.updatedAt = new Date().toISOString();
+      derived.memory.capturedCursor = targetCursor;
+      derived.memory.status = "complete";
+      derived.memory.lastError = undefined;
+      derived.memory.updatedAt = new Date().toISOString();
+    }
+
+    try {
+      await conv.syncLabels(session, snapshot, true);
+      await conv.syncBody(session, snapshot, summaryText, true, titleOverride);
+      derived.summary.text = summaryText;
+      derived.summary.basedOnCursor = targetCursor;
+      derived.summary.status = "complete";
+      derived.summary.lastError = undefined;
+      derived.summary.updatedAt = new Date().toISOString();
+      if (titleOverride?.trim()) {
+        derived.summary.title = titleOverride.trim();
+        session.issueTitle = titleOverride.trim();
+        if (generatedTitle) session.titleSource = "llm";
+      }
+      if (options.markFinalized && !session.finalizedAt) session.finalizedAt = new Date().toISOString();
+    } catch (error) {
+      derived.summary.status = "error";
+      derived.summary.lastError = String(error);
+      derived.summary.updatedAt = new Date().toISOString();
+      this.warn(`${options.reason} summary sync for ${session.sessionId}`, error);
+    }
+
+    session.updatedAt = new Date().toISOString();
     await this.persistState();
-    this.kickDerivedWork(scopeKey, agentId, p.reason ?? "finalize");
+  }
+
+  private async resolveFinalArtifacts(
+    session: SessionMirrorState,
+    snapshot: TranscriptSnapshot,
+    conv: ConversationMirror,
+    mem: MemoryStore,
+  ): Promise<{ summary: string; title?: string; candidates: MemoryCandidate[] }> {
+    const cached = getCachedFinalArtifacts(session, snapshot.messages.length);
+    if (cached) return cached;
+
+    let schema;
+    try {
+      schema = await mem.listSchema();
+    } catch (error) {
+      this.warn(`finalize schema load for ${session.sessionId}`, error);
+    }
+
+    const artifacts = await conv.generateFinalArtifacts(session, snapshot, schema);
+    const derived = this.ensureDerived(session);
+    const now = new Date().toISOString();
+    derived.summary.text = artifacts.summary;
+    derived.summary.title = artifacts.title?.trim() || undefined;
+    derived.summary.basedOnCursor = snapshot.messages.length;
+    derived.summary.lastError = undefined;
+    derived.summary.updatedAt = now;
+    derived.memory.candidates = artifacts.candidates;
+    derived.memory.lastError = undefined;
+    derived.memory.updatedAt = now;
+    return artifacts;
+  }
+
+  private async applyFinalMemoryCandidates(
+    session: SessionMirrorState,
+    mem: MemoryStore,
+    route: ClawMemResolvedRoute,
+    targetCursor: number,
+    candidates: MemoryCandidate[],
+  ): Promise<number> {
+    const derived = this.ensureDerived(session);
+    if (derived.memory.capturedCursor >= targetCursor && derived.memory.status === "complete") {
+      derived.memory.candidates = undefined;
+      return 0;
+    }
+    if (candidates.length === 0) {
+      derived.memory.candidates = undefined;
+      derived.memory.capturedCursor = targetCursor;
+      derived.memory.status = "complete";
+      derived.memory.lastError = undefined;
+      derived.memory.updatedAt = new Date().toISOString();
+      return 0;
+    }
+    try {
+      const result = await this.enqueueRepoWrite(this.repoWriteKey(route), async () => {
+        let createdCount = 0;
+        for (const candidate of candidates) {
+          const stored = await mem.store({
+            ...(candidate.title ? { title: candidate.title } : {}),
+            detail: candidate.detail,
+            ...(candidate.kind ? { kind: candidate.kind } : {}),
+            ...(candidate.topics?.length ? { topics: candidate.topics } : {}),
+          });
+          if (stored.created) createdCount++;
+        }
+        return createdCount;
+      });
+      derived.memory.candidates = undefined;
+      derived.memory.capturedCursor = targetCursor;
+      derived.memory.status = "complete";
+      derived.memory.lastError = undefined;
+      derived.memory.updatedAt = new Date().toISOString();
+      return result;
+    } catch (error) {
+      derived.memory.candidates = candidates;
+      derived.memory.status = "error";
+      derived.memory.lastError = String(error);
+      derived.memory.updatedAt = new Date().toISOString();
+      this.warn(`finalize memory store for ${session.sessionId}`, error);
+      return 0;
+    }
   }
 
   // --- Infrastructure ---
@@ -1440,9 +2074,6 @@ class ClawMemService {
   private enqueueSessionIo<T>(sessionId: string, task: () => Promise<T>): Promise<T> {
     return this.ioQueue.enqueue(sessionId, async () => { await this.ensureLoaded(); return task(); });
   }
-  private enqueueSessionDerived<T>(sessionId: string, task: () => Promise<T>): Promise<T> {
-    return this.deriveQueue.enqueue(sessionId, async () => { await this.ensureLoaded(); return task(); });
-  }
   private enqueueRepoWrite<T>(repoKey: string, task: () => Promise<T>): Promise<T> {
     return this.repoWriteQueue.enqueue(repoKey, task);
   }
@@ -1469,15 +2100,10 @@ class ClawMemService {
       lastMirroredCount: 0,
       turnCount: 0,
       derived: {
-        digest: { cursor: 0, status: "idle", attempt: 0 },
         summary: { basedOnCursor: 0, status: "idle" },
         memory: {
-          extractCursor: 0,
-          appliedCursor: 0,
-          extractStatus: "idle",
-          reconcileStatus: "idle",
-          attempt: 0,
-          pendingCandidates: [],
+          capturedCursor: 0,
+          status: "idle",
         },
       },
       createdAt: now,
@@ -1490,68 +2116,15 @@ class ClawMemService {
   private ensureDerived(session: SessionMirrorState): SessionDerivedState {
     if (!session.derived) {
       session.derived = {
-        digest: { cursor: 0, status: "idle", attempt: 0 },
         summary: { basedOnCursor: 0, status: "idle" },
         memory: {
-          extractCursor: 0,
-          appliedCursor: session.lastMemorySyncCount ?? 0,
-          extractStatus: "idle",
-          reconcileStatus: "idle",
-          attempt: 0,
-          pendingCandidates: [],
+          capturedCursor: 0,
+          status: "idle",
         },
       };
     }
     return session.derived;
   }
-
-  private syncLegacyTaskFields(session: SessionMirrorState): void {
-    const derived = this.ensureDerived(session);
-    session.summaryStatus = derived.summary.status === "complete" ? "complete" : session.finalizedAt ? "pending" : undefined;
-    session.lastMemorySyncCount = derived.memory.appliedCursor;
-  }
-
-  private hasMeaningfulTranscript(session: SessionMirrorState): boolean {
-    return Math.max(session.lastMirroredCount, session.turnCount) >= 2;
-  }
-
-  private needsDigest(session: SessionMirrorState): boolean {
-    if (!this.hasMeaningfulTranscript(session)) return false;
-    const derived = this.ensureDerived(session);
-    return derived.digest.cursor < session.lastMirroredCount;
-  }
-
-  private needsFinalSummary(session: SessionMirrorState): boolean {
-    if (!session.finalizedAt || !this.hasMeaningfulTranscript(session)) return false;
-    const derived = this.ensureDerived(session);
-    return derived.summary.status !== "complete" || derived.summary.basedOnCursor < session.lastMirroredCount;
-  }
-
-  private needsMemoryExtract(session: SessionMirrorState): boolean {
-    if (!this.hasMeaningfulTranscript(session)) return false;
-    const derived = this.ensureDerived(session);
-    return derived.memory.extractCursor < session.lastMirroredCount;
-  }
-
-  private needsMemoryReconcile(session: SessionMirrorState): boolean {
-    if (!this.hasMeaningfulTranscript(session)) return false;
-    const derived = this.ensureDerived(session);
-    return derived.memory.pendingCandidates.length > 0 || derived.memory.appliedCursor < derived.memory.extractCursor;
-  }
-
-  private markPostMirrorTasks(session: SessionMirrorState): void {
-    const derived = this.ensureDerived(session);
-    if (this.needsDigest(session)) derived.digest.status = "pending";
-    if (this.needsMemoryExtract(session)) derived.memory.extractStatus = "pending";
-    if (this.needsMemoryReconcile(session)) derived.memory.reconcileStatus = "pending";
-    this.syncLegacyTaskFields(session);
-  }
-
-  private markSummaryPending(session: SessionMirrorState): void {
-    const derived = this.ensureDerived(session);
-    derived.summary.status = "pending";
-    this.syncLegacyTaskFields(session);
-  }
   private resolveTranscriptAgentId(sessionId: string, sessionFile: string): string | null {
     const fromPath = inferAgentIdFromTranscriptPath(sessionFile);
     if (fromPath) return fromPath;
@@ -1676,279 +2249,6 @@ class ClawMemService {
       },
     });
   }
-  private clearRecoveryTimer(scopeKey: string): void {
-    const prev = this.recoveryTimers.get(scopeKey);
-    if (!prev) return;
-    clearTimeout(prev);
-    this.recoveryTimers.delete(scopeKey);
-  }
-
-  private recoverDerivedWorkOnStart(): void {
-    const recoverableSessions = Object.values(this.state.sessions)
-      .filter((session) => this.sessionNeedsDerivedWork(session))
-      .sort((a, b) => Date.parse(b.updatedAt ?? b.createdAt ?? "") - Date.parse(a.updatedAt ?? a.createdAt ?? ""));
-    for (const session of recoverableSessions) {
-      this.scheduleDerivedRecovery(sessionScopeKey(session.sessionId, session.agentId), normalizeAgentId(session.agentId), {
-        delayMs: 0,
-        attempt: 0,
-        reason: "startup-recovery",
-      });
-    }
-  }
-
-  private kickDerivedWork(scopeKey: string, agentId: string, reason: string): void {
-    this.clearRecoveryTimer(scopeKey);
-    void this.track(this.enqueueSessionDerived(scopeKey, () => this.runSessionDerivedWork(scopeKey, agentId, 0, reason)))
-      .catch((error) => this.warn(`derived work for ${scopeKey}`, error));
-  }
-
-  private scheduleDerivedRecovery(
-    scopeKey: string,
-    agentId: string,
-    options: { delayMs?: number; attempt?: number; reason?: string } = {},
-  ): void {
-    this.clearRecoveryTimer(scopeKey);
-    const delayMs = Math.max(0, options.delayMs ?? 0);
-    const attempt = Math.max(0, options.attempt ?? 0);
-    const reason = options.reason ?? "scheduled-recovery";
-    const timer = setTimeout(() => {
-      this.recoveryTimers.delete(scopeKey);
-      void this.track(this.enqueueSessionDerived(scopeKey, () => this.runSessionDerivedWork(scopeKey, agentId, attempt, reason)))
-        .catch((error) => this.warn(`derived recovery for ${scopeKey}`, error));
-    }, delayMs);
-    timer.unref?.();
-    this.recoveryTimers.set(scopeKey, timer);
-  }
-
-  private async runSessionDerivedWork(scopeKey: string, agentId: string, attempt: number, reason: string): Promise<void> {
-    const session = this.state.sessions[scopeKey];
-    if (!session || !this.sessionNeedsDerivedWork(session)) return;
-    if (!(await this.ensureDefaultRepoConfigured(agentId))) return;
-    const { route, conv, mem, client } = this.getServices(agentId);
-    const snap = await conv.loadSnapshot(session, []);
-    if (!conv.shouldMirror(session.sessionId, snap.messages) || snap.messages.length === 0) return;
-
-    let retryNeeded = false;
-    const derived = this.ensureDerived(session);
-    const updateLegacyAndPersist = async (): Promise<void> => {
-      this.syncLegacyTaskFields(session);
-      await this.persistState();
-    };
-    const mirroredCount = Math.min(session.lastMirroredCount, snap.messages.length);
-    if (mirroredCount <= 0) return;
-    const canCombineDeltaDerivation = this.needsDigest(session)
-      && this.needsMemoryExtract(session)
-      && derived.digest.cursor === derived.memory.extractCursor;
-
-    if (canCombineDeltaDerivation) {
-      const deriveTarget = mirroredCount;
-      const deriveFromCursor = Math.min(derived.digest.cursor, deriveTarget);
-      const deriveSnapshot: TranscriptSnapshot = { ...snap, messages: snap.messages.slice(0, deriveTarget) };
-      const startedAt = new Date().toISOString();
-      derived.digest.status = "running";
-      derived.digest.updatedAt = startedAt;
-      derived.memory.extractStatus = "running";
-      derived.memory.updatedAt = startedAt;
-      await updateLegacyAndPersist();
-      try {
-        const result = await conv.deriveDelta(session, deriveSnapshot, deriveFromCursor, derived.digest.text);
-        derived.digest.text = result.digest.trim();
-        derived.digest.title = result.title?.trim() || derived.digest.title;
-        derived.digest.cursor = deriveTarget;
-        derived.digest.status = deriveTarget < session.lastMirroredCount ? "pending" : "complete";
-        derived.digest.attempt = 0;
-        derived.digest.lastError = undefined;
-        derived.digest.updatedAt = new Date().toISOString();
-        if (result.title?.trim() && session.issueNumber) {
-          await client.updateIssue(session.issueNumber, { title: result.title.trim() });
-          session.issueTitle = result.title.trim();
-          session.titleSource = "digest";
-        }
-
-        derived.memory.pendingCandidates = mergeMemoryCandidates(derived.memory.pendingCandidates, result.candidates);
-        derived.memory.extractCursor = deriveTarget;
-        derived.memory.extractStatus = deriveTarget < session.lastMirroredCount ? "pending" : "complete";
-        derived.memory.attempt = 0;
-        derived.memory.lastError = undefined;
-        derived.memory.updatedAt = new Date().toISOString();
-        if (derived.memory.pendingCandidates.length === 0) {
-          derived.memory.appliedCursor = Math.max(derived.memory.appliedCursor, deriveTarget);
-          derived.memory.reconcileStatus = "complete";
-        } else {
-          derived.memory.reconcileStatus = "pending";
-        }
-      } catch (error) {
-        const failedAt = new Date().toISOString();
-        derived.digest.status = "error";
-        derived.digest.attempt += 1;
-        derived.digest.lastError = String(error);
-        derived.digest.updatedAt = failedAt;
-        derived.memory.extractStatus = "error";
-        derived.memory.attempt += 1;
-        derived.memory.lastError = String(error);
-        derived.memory.updatedAt = failedAt;
-        retryNeeded = true;
-        this.warn(`background derive delta for ${session.sessionId}`, error);
-      }
-      await updateLegacyAndPersist();
-    }
-
-    if (!canCombineDeltaDerivation && this.needsDigest(session)) {
-      const digestTarget = mirroredCount;
-      const digestFromCursor = Math.min(derived.digest.cursor, digestTarget);
-      const digestSnapshot: TranscriptSnapshot = { ...snap, messages: snap.messages.slice(0, digestTarget) };
-      derived.digest.status = "running";
-      derived.digest.updatedAt = new Date().toISOString();
-      await updateLegacyAndPersist();
-      try {
-        const result = await conv.generateRollingDigest(session, digestSnapshot, digestFromCursor, derived.digest.text);
-        derived.digest.text = result.digest.trim();
-        derived.digest.title = result.title?.trim() || derived.digest.title;
-        derived.digest.cursor = digestTarget;
-        derived.digest.status = digestTarget < session.lastMirroredCount ? "pending" : "complete";
-        derived.digest.attempt = 0;
-        derived.digest.lastError = undefined;
-        derived.digest.updatedAt = new Date().toISOString();
-        if (result.title?.trim() && session.issueNumber) {
-          await client.updateIssue(session.issueNumber, { title: result.title.trim() });
-          session.issueTitle = result.title.trim();
-          session.titleSource = "digest";
-        }
-      } catch (error) {
-        derived.digest.status = "error";
-        derived.digest.attempt += 1;
-        derived.digest.lastError = String(error);
-        derived.digest.updatedAt = new Date().toISOString();
-        retryNeeded = true;
-        this.warn(`background digest sync for ${session.sessionId}`, error);
-      }
-      await updateLegacyAndPersist();
-    }
-
-    if (this.needsFinalSummary(session) && derived.digest.cursor >= session.lastMirroredCount) {
-      const summaryTarget = Math.min(session.lastMirroredCount, snap.messages.length);
-      const summarySnapshot: TranscriptSnapshot = { ...snap, messages: snap.messages.slice(0, summaryTarget) };
-      derived.summary.status = "running";
-      derived.summary.updatedAt = new Date().toISOString();
-      await updateLegacyAndPersist();
-      try {
-        const result = await conv.generateFinalSummaryFromDigest(session, summarySnapshot, derived.digest.text ?? "");
-        await conv.syncLabels(session, summarySnapshot, true);
-        await conv.syncBody(session, summarySnapshot, result.summary, true, result.title);
-        derived.summary.text = result.summary;
-        derived.summary.status = summaryTarget < session.lastMirroredCount ? "pending" : "complete";
-        derived.summary.basedOnCursor = summaryTarget;
-        derived.summary.lastError = undefined;
-        derived.summary.updatedAt = new Date().toISOString();
-        if (result.title?.trim()) {
-          session.issueTitle = result.title.trim();
-          session.titleSource = "llm";
-        }
-        this.maybeAutoNameRepo(agentId, result.summary, result.title);
-      } catch (error) {
-        derived.summary.status = "error";
-        derived.summary.lastError = String(error);
-        derived.summary.updatedAt = new Date().toISOString();
-        retryNeeded = true;
-        this.warn(`background summary sync for ${session.sessionId}`, error);
-      }
-      await updateLegacyAndPersist();
-    }
-
-    if (!canCombineDeltaDerivation && this.needsMemoryExtract(session)) {
-      const extractTarget = Math.min(session.lastMirroredCount, snap.messages.length);
-      const extractFromCursor = Math.min(derived.memory.extractCursor, extractTarget);
-      const extractSnapshot: TranscriptSnapshot = { ...snap, messages: snap.messages.slice(0, extractTarget) };
-      derived.memory.extractStatus = "running";
-      derived.memory.updatedAt = new Date().toISOString();
-      await updateLegacyAndPersist();
-      try {
-        const candidates = await mem.extractCandidates(session, extractSnapshot, extractFromCursor, derived.digest.text);
-        derived.memory.pendingCandidates = mergeMemoryCandidates(derived.memory.pendingCandidates, candidates);
-        derived.memory.extractCursor = extractTarget;
-        derived.memory.extractStatus = extractTarget < session.lastMirroredCount ? "pending" : "complete";
-        derived.memory.attempt = 0;
-        derived.memory.lastError = undefined;
-        derived.memory.updatedAt = new Date().toISOString();
-        if (derived.memory.pendingCandidates.length === 0) {
-          derived.memory.appliedCursor = Math.max(derived.memory.appliedCursor, extractTarget);
-          derived.memory.reconcileStatus = "complete";
-        } else {
-          derived.memory.reconcileStatus = "pending";
-        }
-      } catch (error) {
-        derived.memory.extractStatus = "error";
-        derived.memory.attempt += 1;
-        derived.memory.lastError = String(error);
-        derived.memory.updatedAt = new Date().toISOString();
-        retryNeeded = true;
-        this.warn(`background memory extract for ${session.sessionId}`, error);
-      }
-      await updateLegacyAndPersist();
-    }
-
-    if (this.needsMemoryReconcile(session)) {
-      if (derived.memory.pendingCandidates.length === 0) {
-        derived.memory.appliedCursor = derived.memory.extractCursor;
-        derived.memory.reconcileStatus = "complete";
-        derived.memory.updatedAt = new Date().toISOString();
-        await updateLegacyAndPersist();
-      } else {
-        const candidates = mergeMemoryCandidates([], derived.memory.pendingCandidates);
-        derived.memory.reconcileStatus = "running";
-        derived.memory.updatedAt = new Date().toISOString();
-        await updateLegacyAndPersist();
-        try {
-          const decision = await mem.reconcileCandidates(session, candidates);
-          const { savedCount, staledCount } = await this.enqueueRepoWrite(
-            this.repoWriteKey(route),
-            () => mem.applyReconciledDecision(decision),
-          );
-          if (savedCount > 0 || staledCount > 0) {
-            this.api.logger.info?.(
-              `clawmem: synced memories for ${session.sessionId} (saved=${savedCount}, stale=${staledCount})`,
-            );
-          }
-          const consumed = new Set(candidates.map((candidate) => candidate.candidateId));
-          derived.memory.pendingCandidates = derived.memory.pendingCandidates.filter((candidate) => !consumed.has(candidate.candidateId));
-          derived.memory.appliedCursor = derived.memory.extractCursor;
-          derived.memory.reconcileStatus = derived.memory.pendingCandidates.length > 0 ? "pending" : "complete";
-          derived.memory.attempt = 0;
-          derived.memory.lastError = undefined;
-          derived.memory.updatedAt = new Date().toISOString();
-        } catch (error) {
-          derived.memory.reconcileStatus = "error";
-          derived.memory.attempt += 1;
-          derived.memory.lastError = String(error);
-          derived.memory.updatedAt = new Date().toISOString();
-          retryNeeded = true;
-          this.warn(`background memory reconcile for ${session.sessionId}`, error);
-        }
-        await updateLegacyAndPersist();
-      }
-    }
-
-    if (retryNeeded && this.sessionNeedsDerivedWork(session)) {
-      const delayMs = DERIVED_WORK_RECOVERY_DELAYS_MS[Math.min(attempt, DERIVED_WORK_RECOVERY_DELAYS_MS.length - 1)] ?? 120000;
-      this.api.logger.warn?.(
-        `clawmem: derived work incomplete for ${session.sessionId}; retrying in ${Math.round(delayMs / 1000)}s (${reason})`,
-      );
-      this.scheduleDerivedRecovery(scopeKey, agentId, { delayMs, attempt: attempt + 1, reason: "retry" });
-      return;
-    }
-
-    if (this.sessionNeedsDerivedWork(session)) {
-      this.kickDerivedWork(scopeKey, agentId, "follow-up");
-    }
-  }
-
-  private sessionNeedsDerivedWork(session: SessionMirrorState): boolean {
-    return this.needsDigest(session)
-      || this.needsFinalSummary(session)
-      || this.needsMemoryExtract(session)
-      || this.needsMemoryReconcile(session);
-  }
-
   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);
@@ -1956,7 +2256,7 @@ class ClawMemService {
       route,
       client,
       conv: new ConversationMirror(client, this.api, this.config),
-      mem: new MemoryStore(client, this.api, this.config),
+      mem: new MemoryStore(client),
     };
   }
   private resolveToolAgentId(agentId: unknown): string {
@@ -2040,28 +2340,6 @@ class ClawMemService {
     }
     return { value };
   }
-  /**
-   * 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)}`); }
 }
 
@@ -2123,6 +2401,51 @@ export function buildAutoRecallContext(memories: Array<{
   ].join("\n");
 }
 
+export function buildClawMemPromptSection(params: MemoryPromptBuilderParams): string[] {
+  const hasTool = (name: string) => params.availableTools.has(name);
+  const retrievalTools = [
+    hasTool("memory_recall") ? "`memory_recall`" : "",
+    hasTool("memory_list") ? "`memory_list`" : "",
+    hasTool("memory_get") ? "`memory_get`" : "",
+  ].filter(Boolean);
+  const routingTools = [hasTool("memory_repos") ? "`memory_repos`" : ""].filter(Boolean);
+  const schemaTools = [hasTool("memory_labels") ? "`memory_labels`" : ""].filter(Boolean);
+  const writeTools = [
+    hasTool("memory_store") ? "`memory_store`" : "",
+    hasTool("memory_update") ? "`memory_update`" : "",
+  ].filter(Boolean);
+  const hasForgetTool = hasTool("memory_forget");
+
+  const lines = [
+    "## ClawMem",
+    "ClawMem is the active long-term memory system for this OpenClaw installation.",
+    "Core loop:",
+    "- Before answering, ask whether prior memory could improve the answer. Default to yes for preferences, project history, decisions, lessons, workflows, conventions, recurring problems, and active tasks.",
+    `- Treat auto-injected ClawMem context as a hint, not proof of absence.${retrievalTools.length > 0 ? ` If relevant memory may exist and the hint is weak or missing, retrieve explicitly with ${joinNaturalLanguageList(retrievalTools)}.` : ""}`,
+    `${routingTools.length > 0 ? `- Before explicit memory work, choose the right repo. If unclear, inspect ${joinNaturalLanguageList(routingTools)} and then fall back to the agent's default repo.` : "- Before explicit memory work, choose the right repo instead of assuming every memory belongs in the default repo."}`,
+    `${writeTools.length > 0 || hasForgetTool
+      ? `- After answering, ask whether this turn created durable knowledge. If yes or unsure, write it now${writeTools.length > 0 ? ` with ${joinNaturalLanguageList(writeTools)}` : ""}${hasForgetTool ? `${writeTools.length > 0 ? "; " : " "}use \`memory_forget\` for stale or superseded memories` : ""} instead of waiting for background extraction.`
+      : "- After answering, ask whether this turn created durable knowledge and save it immediately instead of waiting for background extraction."}`,
+    "- Store one durable fact per memory. Skip temporary requests, tool chatter, startup boilerplate, and bundled summaries of unrelated facts.",
+    "- Prefer an explicit short `title` plus a fuller `detail`. Write new human-readable memory text in the user's current language and keep structural labels machine-readable.",
+    `${schemaTools.length > 0
+      ? `- Reuse existing \`kind\` and \`topic\` labels by checking ${joinNaturalLanguageList(schemaTools)} first. If no current label fits, create one short stable machine-readable label instead of a translated or near-duplicate variant.`
+      : "- Reuse existing `kind` and `topic` labels before inventing new ones. If no current label fits, create one short stable machine-readable label instead of a translated or near-duplicate variant."}`,
+    "- Use the bundled `clawmem` skill for detailed routing, schema, collaboration, communication, and manual repo-backed workflows.",
+    "",
+  ];
+
+  return lines;
+}
+
+function buildFallbackPromptGuidanceText(event: unknown): string | undefined {
+  const record = asRecord(event);
+  const availableTools = resolvePromptGuidanceAvailableTools(record.availableTools);
+  const citationsMode = typeof record.citationsMode === "string" ? record.citationsMode.trim() || undefined : undefined;
+  const text = buildClawMemPromptSection({ availableTools, ...(citationsMode ? { citationsMode } : {}) }).join("\n").trim();
+  return text || undefined;
+}
+
 export function extractPromptTextForRecall(event: unknown): string | undefined {
   const direct = normalizePromptText(event);
   if (direct) return direct;
@@ -2143,6 +2466,32 @@ export function extractPromptTextForRecall(event: unknown): string | undefined {
     ?? promptCandidates.find((candidate) => candidate.text)?.text;
 }
 
+function joinNaturalLanguageList(items: string[]): string {
+  if (items.length === 0) return "";
+  if (items.length === 1) return items[0]!;
+  if (items.length === 2) return `${items[0]} and ${items[1]}`;
+  return `${items.slice(0, -1).join(", ")}, and ${items[items.length - 1]}`;
+}
+
+function resolvePromptGuidanceAvailableTools(value: unknown): Set<string> {
+  const names = collectToolNames(value);
+  return names.size > 0 ? names : new Set(CLAWMEM_PROMPT_GUIDANCE_TOOL_NAMES);
+}
+
+function collectToolNames(value: unknown): Set<string> {
+  const names = new Set<string>();
+  const values = value instanceof Set ? [...value] : Array.isArray(value) ? value : [];
+  for (const entry of values) {
+    if (typeof entry === "string" && entry.trim()) {
+      names.add(entry.trim());
+      continue;
+    }
+    const record = asRecord(entry);
+    if (typeof record.name === "string" && record.name.trim()) names.add(record.name.trim());
+  }
+  return names;
+}
+
 function extractPromptTextFromMessages(value: unknown): string | undefined {
   if (!Array.isArray(value)) return undefined;
   let fallback: string | undefined;
@@ -2207,6 +2556,23 @@ function candidatePromptText(value: unknown): { text?: string; changed: boolean
   return { changed: false };
 }
 
+function getCachedFinalArtifacts(
+  session: SessionMirrorState,
+  targetCursor: number,
+): { summary: string; title?: string; candidates: MemoryCandidate[] } | null {
+  const derived = session.derived;
+  if (!derived) return null;
+  const summary = derived.summary.text?.trim();
+  if (!summary || derived.summary.basedOnCursor < targetCursor) return null;
+  const hasCachedMemory = Array.isArray(derived.memory.candidates) || derived.memory.capturedCursor >= targetCursor;
+  if (!hasCachedMemory) return null;
+  return {
+    summary,
+    ...(derived.summary.title?.trim() ? { title: derived.summary.title.trim() } : {}),
+    candidates: Array.isArray(derived.memory.candidates) ? derived.memory.candidates : [],
+  };
+}
+
 export function resolvePromptHookMode(api: Pick<OpenClawPluginApi, "runtime">): PromptHookMode {
   const hostVersion = resolveOpenClawHostVersion(api);
   if (!hostVersion) return "legacy";
@@ -2377,6 +2743,20 @@ function renderUserOrganizationInvitationLine(invitation: { id?: number; role?:
   return `${org} [role:${role}${idText}${created}${expires}${teamsText}${inviter}]`;
 }
 
+function renderOrganizationMembershipLine(membership: {
+  state?: string;
+  role?: string;
+  organization?: { login?: string };
+  user?: { login?: string; name?: string };
+}): string {
+  const login = membership.user?.login?.trim() || membership.user?.name?.trim() || "unknown-user";
+  const name = membership.user?.name?.trim() && membership.user?.name?.trim() !== login ? ` (${membership.user.name.trim()})` : "";
+  const state = membership.state?.trim() || "unknown";
+  const role = membership.role?.trim() || "unknown";
+  const org = membership.organization?.login?.trim();
+  return `${login}${name} [state:${state} role:${role}${org ? ` org:${org}` : ""}]`;
+}
+
 function canonicalPermission(permissions?: Record<string, boolean | undefined>, explicit?: string): string {
   const direct = normalizePermissionAlias(explicit);
   if (direct) return direct;
@@ -2398,4 +2778,9 @@ function normalizePermissionAlias(value: unknown): "none" | CollaborationPermiss
   return undefined;
 }
 
+function isHttpStatusError(error: unknown, status: number): boolean {
+  const value = String(error);
+  return value.includes(`HTTP ${status}:`);
+}
+
 export function createClawMemPlugin(api: OpenClawPluginApi): void { new ClawMemService(api).register(); }