@clawmem-ai/clawmem 0.1.9 → 0.1.11

package/skills/clawmem/references/schema.md

@@ -0,0 +1,63 @@
+# ClawMem Memory Schema
+
+Use this reference when deciding how to label or shape a memory, or when you need to explain the ClawMem graph model to another agent or user.
+
+## The memory graph
+
+Issues are nodes. Labels are schema. `#ID` references are edges.
+
+When one memory depends on, refines, supersedes, or generalizes another memory, mention the related `#ID` in the issue body so the relationship stays explicit in the graph.
+
+There are two valid memory shapes:
+- Plugin-managed structured memories: created through `memory_store` or `memory_update`; the plugin manages core labels and may also persist agent-selected `kind:*` and `topic:*` labels
+- Curated graph memories: created manually through `gh` or `curl` when you explicitly need raw issue control
+
+## Labels
+
+Plugin-managed memories always include:
+- `type:memory`
+
+Plugin-managed memories may also include:
+- one `kind:*` label
+- optional `topic:*` labels
+
+Lifecycle is carried by native issue state:
+- open issue = active memory
+- closed issue = stale or superseded memory
+
+If you create a curated memory manually, include:
+- `type:memory`
+- one `kind:*` label
+- optional `topic:*` labels, usually no more than two or three
+
+## Kinds
+
+| Kind | Label | Use it for |
+|---|---|---|
+| Core fact | `kind:core-fact` | Stable truths that should update in place as reality changes |
+| Convention | `kind:convention` | Agreed rules or policies |
+| Lesson learned | `kind:lesson` | Corrections, postmortems, or mistakes worth preserving |
+| Skill blueprint | `kind:skill` | Repeatable workflows or playbooks |
+| Active task | `kind:task` | Ongoing work that should stay visible and update over time |
+
+## When to create which kind
+
+| Trigger | Kind |
+|---|---|
+| User corrects a wrong assumption | `kind:lesson` |
+| You and the user agree on a rule | `kind:convention` |
+| A stable fact about the user or project | `kind:core-fact` |
+| A repeatable workflow you figured out | `kind:skill` |
+| Ongoing work to track | `kind:task` |
+
+## Disciplined self-evolution
+
+- Before inventing a new `kind` or `topic`, call `memory_labels`.
+- Reuse current schema when it already fits.
+- If the current schema does not fit and a new label would help future retrieval, coordination, or reuse, create it deliberately.
+- New labels should be short, general, and likely to apply again across future memories or agents.
+- Do not invent random label prefixes. Schema evolution must stay within `kind:*` and `topic:*`.
+
+## Storage rule
+
+If you are writing something so the agent remembers it later, store it in ClawMem. If you are writing something for a tool or human to read directly, write a file instead.

package/skills/clawmem/scripts/clawmem_exports.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+
+import json
+import os
+import shlex
+import subprocess
+import sys
+
+
+def normalize_base_url(raw: str) -> str:
+    value = (raw or "https://git.clawmem.ai/api/v3").rstrip("/")
+    if not value.endswith("/api/v3"):
+        value = f"{value}/api/v3"
+    return value
+
+
+def main() -> int:
+    agent_id = (sys.argv[1].strip() if len(sys.argv) > 1 and sys.argv[1].strip() else os.environ.get("OPENCLAW_AGENT_ID", "main"))
+    repo_override = sys.argv[2].strip() if len(sys.argv) > 2 else ""
+
+    try:
+        cfg_path = subprocess.check_output(["openclaw", "config", "file"], text=True).strip()
+    except FileNotFoundError:
+        print("clawmem_exports.py: openclaw CLI was not found in PATH", file=sys.stderr)
+        return 1
+    with open(os.path.expanduser(cfg_path), "r", encoding="utf-8") as handle:
+        root = json.load(handle)
+
+    cfg = (((root.get("plugins") or {}).get("entries") or {}).get("clawmem") or {}).get("config") or {}
+    agents = cfg.get("agents") or {}
+    route = agents.get(agent_id) or {}
+
+    base_url = normalize_base_url(route.get("baseUrl") or cfg.get("baseUrl") or "")
+    default_repo = route.get("defaultRepo") or route.get("repo") or cfg.get("defaultRepo") or cfg.get("repo") or ""
+    repo = repo_override or default_repo
+    token = route.get("token") or ""
+    host = base_url.removesuffix("/api/v3").replace("https://", "").replace("http://", "")
+
+    pairs = {
+        "CLAWMEM_AGENT_ID": agent_id,
+        "CLAWMEM_BASE_URL": base_url,
+        "CLAWMEM_HOST": host,
+        "CLAWMEM_DEFAULT_REPO": default_repo,
+        "CLAWMEM_REPO": repo,
+        "CLAWMEM_TOKEN": token,
+    }
+
+    for key, value in pairs.items():
+        print(f"export {key}={shlex.quote(value)}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/src/config.test.ts

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

package/src/config.ts

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

package/src/github-client.ts

@@ -1,11 +1,67 @@
 // GitHub Issues API client for clawmem. No label caching — idempotent create-if-absent.
 import { resolveLabelColor, labelDescription, extractLabelNames, isManagedLabel } from "./config.js";
-import type { AnonymousSessionResponse, ClawMemResolvedRoute } from "./types.js";
+import type { AgentRegistrationResponse, AnonymousSessionResponse, ClawMemResolvedRoute } from "./types.js";
 
 type IssueResponse = { number: number; title?: string; body?: string; state?: string; labels?: Array<{ name?: string } | string> };
 type SearchIssuesResponse = { items?: IssueResponse[]; total_count?: number; incomplete_results?: boolean };
 type CommentResponse = { id?: number; body?: string; created_at?: string };
 type LabelResponse = { name?: string; color?: string; description?: string };
+type PermissionMap = Record<string, boolean | undefined>;
+type RepoResponse = {
+  name?: string;
+  full_name?: string;
+  description?: string;
+  private?: boolean;
+  owner?: { login?: string };
+  permissions?: PermissionMap;
+  role_name?: string;
+};
+type OrgResponse = {
+  id?: number;
+  login?: string;
+  name?: string;
+  description?: string;
+  default_repository_permission?: string;
+};
+type TeamResponse = {
+  id?: number;
+  slug?: string;
+  name?: string;
+  description?: string;
+  privacy?: string;
+  permission?: string;
+  role_name?: string;
+  permissions?: PermissionMap;
+};
+type CollaboratorResponse = {
+  id?: number;
+  login?: string;
+  name?: string;
+  permissions?: PermissionMap;
+  role_name?: string;
+};
+type RepositoryInvitationResponse = {
+  id?: number;
+  created_at?: string;
+  permissions?: string;
+  repository?: RepoResponse;
+  invitee?: { login?: string; name?: string };
+  inviter?: { login?: string; name?: string };
+};
+type TeamMembershipResponse = { state?: string; role?: string };
+type InvitationResponse = {
+  id?: number;
+  role?: string;
+  created_at?: string;
+  expires_at?: string | null;
+  email?: string;
+  login?: string;
+  organization?: OrgResponse;
+  invitee?: { login?: string };
+  inviter?: { login?: string };
+  team_ids?: number[];
+  teams?: TeamResponse[];
+};
 type ReqOpts = { allowNotFound?: boolean; allowValidationError?: boolean; omitAuth?: boolean };
 
 export class GitHubIssueClient {
@@ -14,6 +70,9 @@ export class GitHubIssueClient {
   repo(): string | undefined {
     return this.config.repo?.trim() || undefined;
   }
+  defaultRepo(): string | undefined {
+    return this.config.defaultRepo?.trim() || undefined;
+  }
 
   async createIssue(params: { title: string; body: string; labels: string[] }): Promise<IssueResponse> {
     return this.req<IssueResponse>(this.repoPath("issues"), { method: "POST", body: JSON.stringify(params) });
@@ -53,6 +112,144 @@ export class GitHubIssueClient {
     q.set("per_page", String(params?.perPage ?? 100));
     return this.req<LabelResponse[]>(`${this.repoPath("labels")}?${q}`, { method: "GET" });
   }
+  async listUserRepos(): Promise<RepoResponse[]> {
+    return this.req<RepoResponse[]>("user/repos", { method: "GET" });
+  }
+  async createUserRepo(params: { name: string; description?: string; private?: boolean; autoInit?: boolean }): Promise<RepoResponse> {
+    return this.req<RepoResponse>("user/repos", {
+      method: "POST",
+      body: JSON.stringify({
+        name: params.name,
+        ...(params.description ? { description: params.description } : {}),
+        private: params.private ?? true,
+        auto_init: params.autoInit ?? false,
+      }),
+    });
+  }
+  async listUserOrgs(): Promise<OrgResponse[]> {
+    return this.req<OrgResponse[]>("user/orgs", { method: "GET" });
+  }
+  async createUserOrg(params: { login: string; name?: string; defaultRepositoryPermission?: string }): Promise<OrgResponse> {
+    return this.req<OrgResponse>("user/orgs", {
+      method: "POST",
+      body: JSON.stringify({
+        login: params.login,
+        ...(params.name ? { name: params.name } : {}),
+        ...(params.defaultRepositoryPermission ? { default_repository_permission: params.defaultRepositoryPermission } : {}),
+      }),
+    });
+  }
+  async getOrg(org: string): Promise<OrgResponse> {
+    return this.req<OrgResponse>(`orgs/${encodeURIComponent(org)}`, { method: "GET" });
+  }
+  async listOrgTeams(org: string): Promise<TeamResponse[]> {
+    return this.req<TeamResponse[]>(`orgs/${encodeURIComponent(org)}/teams`, { method: "GET" });
+  }
+  async createOrgTeam(org: string, params: { name: string; description?: string; privacy?: "closed" | "secret" }): Promise<TeamResponse> {
+    return this.req<TeamResponse>(`orgs/${encodeURIComponent(org)}/teams`, {
+      method: "POST",
+      body: JSON.stringify({
+        name: params.name,
+        ...(params.description ? { description: params.description } : {}),
+        privacy: params.privacy ?? "closed",
+      }),
+    });
+  }
+  async setTeamMembership(org: string, teamSlug: string, username: string, role: "member" | "maintainer"): Promise<TeamMembershipResponse> {
+    return this.req<TeamMembershipResponse>(
+      `orgs/${encodeURIComponent(org)}/teams/${encodeURIComponent(teamSlug)}/memberships/${encodeURIComponent(username)}`,
+      { method: "PUT", body: JSON.stringify({ role }) },
+    );
+  }
+  async removeTeamMembership(org: string, teamSlug: string, username: string): Promise<void> {
+    await this.req(
+      `orgs/${encodeURIComponent(org)}/teams/${encodeURIComponent(teamSlug)}/memberships/${encodeURIComponent(username)}`,
+      { method: "DELETE" },
+    );
+  }
+  async listTeamRepos(org: string, teamSlug: string): Promise<RepoResponse[]> {
+    return this.req<RepoResponse[]>(`orgs/${encodeURIComponent(org)}/teams/${encodeURIComponent(teamSlug)}/repos`, { method: "GET" });
+  }
+  async setTeamRepoAccess(org: string, teamSlug: string, owner: string, repo: string, permission: "read" | "write" | "admin"): Promise<void> {
+    await this.req(
+      `orgs/${encodeURIComponent(org)}/teams/${encodeURIComponent(teamSlug)}/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`,
+      { method: "PUT", body: JSON.stringify({ permission }) },
+    );
+  }
+  async removeTeamRepoAccess(org: string, teamSlug: string, owner: string, repo: string): Promise<void> {
+    await this.req(
+      `orgs/${encodeURIComponent(org)}/teams/${encodeURIComponent(teamSlug)}/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`,
+      { method: "DELETE" },
+    );
+  }
+  async listRepoCollaborators(owner: string, repo: string): Promise<CollaboratorResponse[]> {
+    return this.req<CollaboratorResponse[]>(
+      `repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/collaborators`,
+      { method: "GET" },
+    );
+  }
+  async listRepoInvitations(owner: string, repo: string): Promise<RepositoryInvitationResponse[]> {
+    return this.req<RepositoryInvitationResponse[]>(
+      `repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/invitations`,
+      { method: "GET" },
+    );
+  }
+  async setRepoCollaborator(owner: string, repo: string, username: string, permission: "read" | "write" | "admin"): Promise<RepositoryInvitationResponse | undefined> {
+    return this.req<RepositoryInvitationResponse>(
+      `repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/collaborators/${encodeURIComponent(username)}`,
+      { method: "PUT", body: JSON.stringify({ permission }) },
+    );
+  }
+  async removeRepoCollaborator(owner: string, repo: string, username: string): Promise<void> {
+    await this.req(
+      `repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/collaborators/${encodeURIComponent(username)}`,
+      { method: "DELETE" },
+    );
+  }
+  async getRepo(owner: string, repo: string): Promise<RepoResponse> {
+    return this.req<RepoResponse>(`repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`, { method: "GET" });
+  }
+  async listRepoTeams(owner: string, repo: string): Promise<TeamResponse[]> {
+    return this.req<TeamResponse[]>(`repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/teams`, { method: "GET" });
+  }
+  async listUserRepoInvitations(): Promise<RepositoryInvitationResponse[]> {
+    return this.req<RepositoryInvitationResponse[]>("user/repository_invitations", { method: "GET" });
+  }
+  async acceptUserRepoInvitation(invitationId: number): Promise<void> {
+    await this.req(`user/repository_invitations/${invitationId}`, { method: "PATCH" });
+  }
+  async declineUserRepoInvitation(invitationId: number): Promise<void> {
+    await this.req(`user/repository_invitations/${invitationId}`, { method: "DELETE" });
+  }
+  async listOrgInvitations(org: string): Promise<InvitationResponse[]> {
+    return this.req<InvitationResponse[]>(`orgs/${encodeURIComponent(org)}/invitations`, { method: "GET" });
+  }
+  async createOrgInvitation(
+    org: string,
+    params: { inviteeLogin: string; role?: "member" | "admin"; teamIds?: number[]; expiresInDays?: number },
+  ): Promise<InvitationResponse> {
+    return this.req<InvitationResponse>(`orgs/${encodeURIComponent(org)}/invitations`, {
+      method: "POST",
+      body: JSON.stringify({
+        invitee_login: params.inviteeLogin,
+        role: params.role ?? "member",
+        ...(params.teamIds && params.teamIds.length > 0 ? { team_ids: params.teamIds } : {}),
+        ...(typeof params.expiresInDays === "number" ? { expires_in_days: params.expiresInDays } : {}),
+      }),
+    });
+  }
+  async listOrgOutsideCollaborators(org: string): Promise<CollaboratorResponse[]> {
+    return this.req<CollaboratorResponse[]>(`orgs/${encodeURIComponent(org)}/outside_collaborators`, { method: "GET" });
+  }
+  async listUserOrgInvitations(): Promise<InvitationResponse[]> {
+    return this.req<InvitationResponse[]>("user/organization_invitations", { method: "GET" });
+  }
+  async acceptUserOrgInvitation(invitationId: number): Promise<void> {
+    await this.req(`user/organization_invitations/${invitationId}`, { method: "PATCH" });
+  }
+  async declineUserOrgInvitation(invitationId: number): Promise<void> {
+    await this.req(`user/organization_invitations/${invitationId}`, { method: "DELETE" });
+  }
   async ensureLabels(labels: string[]): Promise<void> {
     for (const label of labels) {
       if (!label.trim()) continue;
@@ -71,6 +268,15 @@ export class GitHubIssueClient {
   async updateRepoDescription(description: string): Promise<void> {
     await this.req(this.repoPath("").replace(/\/$/, ""), { method: "PATCH", body: JSON.stringify({ description }) });
   }
+  async registerAgent(prefixLogin: string, defaultRepoName: string): Promise<AgentRegistrationResponse> {
+    return this.req<AgentRegistrationResponse>("agents", {
+      method: "POST",
+      body: JSON.stringify({
+        prefix_login: prefixLogin,
+        default_repo_name: defaultRepoName,
+      }),
+    }, { omitAuth: true });
+  }
   async createAnonymousSession(locale?: string): Promise<AnonymousSessionResponse> {
     const body = locale ? JSON.stringify({ locale }) : undefined;
     return this.req<AnonymousSessionResponse>("anonymous/session", { method: "POST", ...(body ? { body } : {}) }, { omitAuth: true });

package/src/memory.test.ts

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

package/src/memory.ts

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