@clawmem-ai/clawmem 0.1.17 → 0.1.19

package/README.md

@@ -7,6 +7,8 @@
 - On session start: searches active memories by relevance and injects them into context.
 - On session reset/end: best-effort writes a final conversation summary/title and stores durable memory candidates as `type:memory` issues.
 - Lets agents inspect memory indexes and schema, fetch exact memories, update canonical facts in place, and write structured memories with `kind:*` and `topic:*` labels through plugin tools.
+- Adds atomic collaboration tools for organizations, repos, teams, invitations, access, issues, and comments.
+- Does not ship any built-in Team workflow or Team template.
 
 ---
 
@@ -20,17 +22,29 @@ openclaw config validate
 openclaw gateway restart
 ```
 
-After restart, confirm OpenClaw shows ClawMem as the active memory plugin. On first use, clawmem bootstraps each agent identity by calling `POST /api/v3/agents` on `git.clawmem.ai`, then writes the returned `token` plus `repo_full_name` back into your config under `plugins.entries.clawmem.config.agents.<agentId>` as that agent's `defaultRepo`. Automatic flows use that `defaultRepo`, while explicit memory tool calls may target other repos. When talking to an older backend that does not expose `POST /api/v3/agents`, the plugin falls back to the deprecated anonymous bootstrap path.
+After restart, confirm OpenClaw shows ClawMem as the active memory plugin. On first use, clawmem bootstraps each agent identity by calling `POST /api/v3/agents` on `git.clawmem.ai`, then writes the returned `token`, backend `login`, and `repo_full_name` back into your config under `plugins.entries.clawmem.config.agents.<agentId>` as that agent's `defaultRepo`. Automatic flows use that `defaultRepo`, while explicit memory tool calls may target other repos. When talking to an older backend that does not expose `POST /api/v3/agents`, the plugin falls back to the deprecated anonymous bootstrap path.
 
-The package now also ships a bundled `clawmem` skill for runtime memory behavior:
+ClawMem installs only the core memory plugin and its core runtime skill. If you want Team setup or Team workflow templates, install an external ClawMem Team skill pack such as `clawmem-team-skills`.
+
+Earlier ClawMem versions bundled Team workflow guidance. That guidance has moved to an external ClawMem Team skill repository such as `clawmem-team-skills`. If you are upgrading from an older setup, install the external Team skill pack before following any Team-related docs.
+
+The package ships a bundled `clawmem` skill for core runtime memory behavior:
 - core recall and save loop
 - post-install repair and verification guidance
 - mental model, user-facing communication, and console-link guidance
 - schema and manual-ops references
-- collaboration routing for shared repos
+- collaboration routing for shared repos and access primitives
 
 The website `SKILL.md` should stay bootstrap-focused. Once the plugin is installed, rely on the bundled plugin skill for day-to-day memory behavior.
 
+## Optional Team Skills
+
+ClawMem plugin = memory + atomic collaboration capability.
+
+external ClawMem Team skill pack = Team design + Team bootstrap + Team templates.
+
+If you want a Team, install that repository separately and use one of its entry skills. The plugin package is not the source of truth for Team workflows.
+
 ---
 
 ## Publishing
@@ -60,12 +74,13 @@ ClawMem is OpenClaw's durable memory system.
 - Durable facts, preferences, decisions, workflows, and active-task state belong in ClawMem memory issues.
 - Files remain for tools or humans to read directly.
 - Memory routing is per agent identity: `plugins.entries.clawmem.config.agents.<agentId>.defaultRepo` is the default space, and explicit tool calls may target other repos.
-- Shared or team memory should live in a shared repo, not in one agent's private default repo.
+- Shared memory can live in shared repos instead of one agent's private default repo.
+- How multiple agents organize around those repos is defined by external skills, not by the plugin.
 - Use plugin tools first. Raw `gh` or `curl` are fallback tools for explicit repo operations, backend debugging, or tool outages.
 
 ## Bundled Skill And Docs
 
-The plugin package is now the runtime source of truth:
+The plugin package is the runtime source of truth for ClawMem core behavior:
 
 - Bundled runtime skill: [`skills/clawmem/SKILL.md`](skills/clawmem/SKILL.md)
 - Runtime references: [`skills/clawmem/references/`](skills/clawmem/references/)
@@ -74,10 +89,12 @@ The plugin package is now the runtime source of truth:
 That bundled skill covers:
 - recall and save behavior
 - schema discipline and deliberate self-evolution
-- shared-memory and collaboration routing
+- shared-memory and collaboration primitives
 - repair and verification guidance
 - raw `gh` / `curl` fallback flows
 
+Team setup guides, Team workflow guides, and Team templates live in an external ClawMem Team skill pack such as `clawmem-team-skills`.
+
 If your environment still relies on file-injected reminders such as `SOUL.md`, `AGENTS.md`, or `TOOLS.md`, treat them as optional compatibility snippets rather than the primary runtime source of truth.
 
 ---
@@ -98,6 +115,7 @@ Minimal config (after auto-provisioning):
           agents: {
             main: {
               baseUrl: "https://git.clawmem.ai/api/v3",
+              login: "main-b54ea6",
               defaultRepo: "owner/main-memory",
               token: "<token>",
               authScheme: "token"
@@ -126,11 +144,13 @@ Full config with all options:
           agents: {
             main: {
               baseUrl: "https://git.clawmem.ai/api/v3",
+              login: "main-b54ea6",
               defaultRepo: "owner/main-memory",
               token: "<token>",
               authScheme: "token"
             },
             coder: {
+              login: "hazel-e23778",
               defaultRepo: "owner/coder-memory",
               token: "<token>"
             }
@@ -146,8 +166,6 @@ Full config with all options:
 }
 ```
 
----
-
 ## Notes
 
 - Conversation comments exclude tool calls, tool results, system messages, and heartbeat noise.
@@ -156,9 +174,10 @@ Full config with all options:
 - Summary or memory-capture failures do not block finalization; the conversation issue still closes, and the mirrored transcript remains the durable source of truth for manual follow-up.
 - Memory search and auto-recall only return open `type:memory` issues. Closed memory issues are treated as stale.
 - ClawMem automatically injects a small set of relevant memories before each turn using the agent's default repo and the backend recall API. Auto-recall is best-effort and quietly skips injection when backend recall is unavailable.
+- Always-on ClawMem prompt guidance uses the dedicated memory prompt-registration API on OpenClaw `2026.3.22+`. On `2026.3.7` through `2026.3.21`, ClawMem falls back to `before_prompt_build` `prependSystemContext`. Older hosts still support auto-recall, tools, and conversation mirroring, but they cannot inject the static always-on guidance.
 - `memory_recall` uses the backend `/api/v3/search/issues` endpoint scoped to the current repo plus `label:"type:memory"`. When backend recall is unavailable, use `memory_list` or `memory_get` to inspect memories explicitly.
 - Automatic durable capture happens when the session resets or ends. If a fact must be available immediately for later turns, use `memory_store` or `memory_update` explicitly instead of waiting for finalization.
-- The plugin exposes `memory_repos`, `memory_repo_create`, `memory_list`, `memory_get`, `memory_labels`, `memory_recall`, `memory_store`, `memory_update`, and `memory_forget` for mid-session use.
+- The plugin exposes memory tools, collaboration tools, a default-repo retarget tool, and generic issue/comment tools for mid-session use.
 - Route resolution is now: agent identity supplies credentials, `defaultRepo` is the fallback memory space, and explicit tool calls may override repo per operation.
 - `memory_store` accepts optional schema hints such as kind and topics; the plugin normalizes them into managed `kind:*` and `topic:*` labels.
 - Memory issues no longer use `session:*` labels. Session linkage remains a conversation concern, not part of the durable memory schema.
@@ -166,3 +185,4 @@ Full config with all options:
 - Conversation lifecycle is stored in native issue state (`open` while live, `closed` after finalize); memory lifecycle uses native issue state too (`open` active, `closed` stale).
 - Memory extraction now prefers one atomic fact per memory item instead of bundling whole sessions into a single node.
 - Memory issue bodies store the durable detail in a YAML `detail` field plus flat metadata such as `memory_hash` and logical `date`; this matches the current Console parser in `agent-git-service/web`.
+- If your environment still exposes older Team-specific reminders from the plugin package, treat them as deprecated compatibility content and follow your external ClawMem Team skill pack for current Team setup guidance.

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
+export default function register(api: OpenClawPluginApi): void;

package/dist/index.js

@@ -0,0 +1,4 @@
+import { createClawMemPlugin } from "./src/service.js";
+export default function register(api) {
+    createClawMemPlugin(api);
+}

package/dist/src/collaboration.d.ts

@@ -0,0 +1,49 @@
+export type CollaborationPermission = "read" | "write" | "admin";
+export type CollaborationOrgInvitationRole = "member" | "owner";
+type PermissionMap = Record<string, boolean | undefined>;
+export type CollaborationRepoSummary = {
+    full_name?: string;
+    owner?: {
+        login?: string;
+    };
+    name?: string;
+    permissions?: PermissionMap;
+    role_name?: string;
+};
+export type CollaborationTeamSummary = {
+    id?: number;
+    slug?: string;
+    name?: string;
+    description?: string;
+    privacy?: string;
+    permission?: string;
+    role_name?: string;
+    permissions?: PermissionMap;
+};
+export type CollaborationCollaboratorSummary = {
+    id?: number;
+    login?: string;
+    name?: string;
+    permissions?: PermissionMap;
+    role_name?: string;
+    organization_member?: boolean;
+    outside_collaborator?: boolean;
+    type?: string;
+};
+type RepoAccessTeamClient = {
+    listOrgTeams(org: string): Promise<CollaborationTeamSummary[]>;
+    listTeamRepos(org: string, teamSlug: string): Promise<CollaborationRepoSummary[]>;
+};
+export declare function normalizePermissionAlias(value: unknown): "none" | CollaborationPermission | undefined;
+export declare function resolveOrgInvitationRole(value: unknown, fallback: CollaborationOrgInvitationRole): {
+    role: CollaborationOrgInvitationRole;
+} | {
+    error: string;
+};
+export declare function repoSummaryFullName(repo?: CollaborationRepoSummary): string | undefined;
+export declare function filterDirectCollaborators(collaborators: CollaborationCollaboratorSummary[], ownerLogin: string): CollaborationCollaboratorSummary[];
+export declare function listRepoAccessTeams(client: RepoAccessTeamClient, org: string, fullName: string): Promise<{
+    teams: CollaborationTeamSummary[];
+    notes: string[];
+}>;
+export {};

package/dist/src/collaboration.js

@@ -0,0 +1,69 @@
+export function normalizePermissionAlias(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (!normalized)
+        return undefined;
+    if (normalized === "none")
+        return "none";
+    if (normalized === "read" || normalized === "pull" || normalized === "triage")
+        return "read";
+    if (normalized === "write" || normalized === "push" || normalized === "maintain")
+        return "write";
+    if (normalized === "admin")
+        return "admin";
+    return undefined;
+}
+export function resolveOrgInvitationRole(value, fallback) {
+    if (value === undefined || value === null || value === "")
+        return { role: fallback };
+    if (typeof value !== "string")
+        return { error: "role must be member or owner." };
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "member" || normalized === "owner")
+        return { role: normalized };
+    return { error: `Unsupported role "${value}". Use member or owner.` };
+}
+export function repoSummaryFullName(repo) {
+    const fullName = repo?.full_name?.trim();
+    if (fullName)
+        return fullName;
+    const owner = repo?.owner?.login?.trim();
+    const name = repo?.name?.trim();
+    if (owner && name)
+        return `${owner}/${name}`;
+    return name || undefined;
+}
+export function filterDirectCollaborators(collaborators, ownerLogin) {
+    const owner = ownerLogin.trim().toLowerCase();
+    if (!owner)
+        return collaborators;
+    return collaborators.filter((collaborator) => (collaborator.login?.trim().toLowerCase() || "") !== owner);
+}
+export async function listRepoAccessTeams(client, org, fullName) {
+    const notes = [];
+    const teams = await client.listOrgTeams(org);
+    const withAccess = [];
+    for (const team of teams) {
+        const teamSlug = team.slug?.trim() || team.name?.trim();
+        if (!teamSlug) {
+            notes.push(`Skipped a team in org "${org}" because it had no slug or name.`);
+            continue;
+        }
+        try {
+            const repos = await client.listTeamRepos(org, teamSlug);
+            const matchingRepo = repos.find((repo) => repoSummaryFullName(repo) === fullName);
+            if (!matchingRepo)
+                continue;
+            withAccess.push({
+                ...team,
+                ...(matchingRepo.permissions ? { permissions: matchingRepo.permissions } : {}),
+                ...(matchingRepo.role_name ? { role_name: matchingRepo.role_name } : {}),
+            });
+        }
+        catch (error) {
+            notes.push(`Team repo lookup failed for ${org}/${teamSlug}: ${String(error)}`);
+        }
+    }
+    return { teams: withAccess, notes };
+}

package/dist/src/config.d.ts

@@ -0,0 +1,21 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
+import type { ClawMemPluginConfig, ClawMemResolvedRoute } from "./types.js";
+export declare const SESSION_TITLE_PREFIX = "Session: ";
+export declare const MEMORY_TITLE_PREFIX = "Memory: ";
+export declare const DEFAULT_LABELS: readonly string[];
+export declare const AGENT_LABEL_PREFIX = "agent:";
+export declare const LABEL_ACTIVE = "status:active";
+export declare const LABEL_CLOSED = "status:closed";
+export declare const LABEL_MEMORY_ACTIVE = "memory-status:active";
+export declare const LABEL_MEMORY_STALE = "memory-status:stale";
+export declare function resolvePluginConfig(api: OpenClawPluginApi): ClawMemPluginConfig;
+export declare function resolveAgentRoute(config: ClawMemPluginConfig, agentId?: string, repoOverride?: string): ClawMemResolvedRoute;
+export declare function isAgentConfigured(route: ClawMemResolvedRoute): boolean;
+export declare function hasDefaultRepo(route: ClawMemResolvedRoute): boolean;
+export declare function resolveLabelColor(label: string): string;
+export declare function labelDescription(label: string): string;
+export declare function isManagedLabel(label: string): boolean;
+export declare function extractLabelNames(labels: Array<{
+    name?: string;
+} | string> | undefined): string[];
+export declare function labelVal(labels: string[], prefix: string): string | undefined;

package/dist/src/config.js

@@ -0,0 +1,119 @@
+import { normalizeAgentId, normalizeLoginName } from "./utils.js";
+export const SESSION_TITLE_PREFIX = "Session: ";
+export const MEMORY_TITLE_PREFIX = "Memory: ";
+export const DEFAULT_LABELS = [];
+export const AGENT_LABEL_PREFIX = "agent:";
+export const LABEL_ACTIVE = "status:active";
+export const LABEL_CLOSED = "status:closed";
+export const LABEL_MEMORY_ACTIVE = "memory-status:active";
+export const LABEL_MEMORY_STALE = "memory-status:stale";
+const MANAGED_PREFIXES = ["type:", "kind:", "session:", "date:", "topic:", "agent:"];
+const MANAGED_EXACT = new Set([LABEL_ACTIVE, LABEL_CLOSED, LABEL_MEMORY_ACTIVE, LABEL_MEMORY_STALE]);
+export function resolvePluginConfig(api) {
+    const raw = (api.pluginConfig ?? {});
+    const str = (v) => typeof v === "string" && v.trim() ? v.trim() : undefined;
+    const num = (v, d) => typeof v === "number" && Number.isFinite(v) ? Math.floor(v) : d;
+    const positiveInt = (v) => typeof v === "number" && Number.isInteger(v) && v > 0 ? v : undefined;
+    const float = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
+    const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+    const baseUrl = (str(raw.baseUrl) ?? "https://git.clawmem.ai").replace(/\/+$/, "");
+    const rawAgents = raw.agents && typeof raw.agents === "object" && !Array.isArray(raw.agents)
+        ? raw.agents
+        : {};
+    const agents = {};
+    for (const [rawAgentId, rawAgentConfig] of Object.entries(rawAgents)) {
+        if (!rawAgentConfig || typeof rawAgentConfig !== "object" || Array.isArray(rawAgentConfig))
+            continue;
+        const agentId = normalizeAgentId(rawAgentId);
+        const agent = rawAgentConfig;
+        agents[agentId] = {
+            baseUrl: str(agent.baseUrl)?.replace(/\/+$/, ""),
+            login: normalizeLoginName(str(agent.login)),
+            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,
+        };
+    }
+    return {
+        baseUrl: baseUrl.endsWith("/api/v3") ? baseUrl : `${baseUrl}/api/v3`,
+        login: normalizeLoginName(str(raw.login)),
+        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),
+        memoryAutoRecallLimit: clamp(num(raw.memoryAutoRecallLimit, 3), 1, 20),
+        summaryWaitTimeoutMs: clamp(num(raw.summaryWaitTimeoutMs, 120000), 1000, 600000),
+        memoryExtractWaitTimeoutMs: clamp(num(raw.memoryExtractWaitTimeoutMs, 45000), 1000, 600000),
+        reviewNudgeInterval: clamp(num(raw.reviewNudgeInterval, 10), 0, 100),
+    };
+}
+export function resolveAgentRoute(config, agentId, repoOverride) {
+    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`,
+        ...(normalizeLoginName(agent.login) ?? normalizeLoginName(config.login) ? { login: normalizeLoginName(agent.login) ?? normalizeLoginName(config.login) } : {}),
+        ...(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) {
+    return Boolean(route.baseUrl && route.token);
+}
+export function hasDefaultRepo(route) {
+    return Boolean(route.defaultRepo);
+}
+export function resolveLabelColor(label) {
+    if (label.startsWith("status:"))
+        return "b60205";
+    if (label.startsWith("memory-status:"))
+        return label.endsWith(":stale") ? "d93f0b" : "0e8a16";
+    if (label.startsWith("type:"))
+        return label === "type:memory" ? "5319e7" : "1d76db";
+    if (label.startsWith("kind:"))
+        return "5319e7";
+    if (label.startsWith("date:"))
+        return "c5def5";
+    if (label.startsWith("topic:"))
+        return "fbca04";
+    if (label.startsWith("session:"))
+        return "bfdadc";
+    if (label.startsWith("agent:"))
+        return "1d76db";
+    return "0e8a16";
+}
+export function labelDescription(label) {
+    for (const [pfx, d] of [["type:", "Issue type"], ["kind:", "Memory kind"], ["memory-status:", "Memory lifecycle status"],
+        ["status:", "Conversation lifecycle status"], ["session:", "Session association"],
+        ["date:", "Date"], ["topic:", "Topic"], ["agent:", "Agent"]])
+        if (label.startsWith(pfx))
+            return `${d} label managed by clawmem.`;
+    return "Label managed by clawmem.";
+}
+export function isManagedLabel(label) {
+    return DEFAULT_LABELS.includes(label) || MANAGED_EXACT.has(label) || MANAGED_PREFIXES.some((p) => label.startsWith(p));
+}
+export function extractLabelNames(labels) {
+    if (!Array.isArray(labels))
+        return [];
+    return labels.map((e) => (typeof e === "string" ? e : e?.name ?? "").trim()).filter(Boolean);
+}
+export function labelVal(labels, prefix) {
+    const m = labels.find((l) => l.startsWith(prefix));
+    return m ? m.slice(prefix.length).trim() || undefined : undefined;
+}
+function normalizeRepoName(value) {
+    if (!value)
+        return undefined;
+    const trimmed = value.trim().replace(/^\/+|\/+$/g, "");
+    return /^[^/\s]+\/[^/\s]+$/.test(trimmed) ? trimmed : undefined;
+}

package/dist/src/conversation.d.ts

@@ -0,0 +1,30 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
+import type { GitHubIssueClient } from "./github-client.js";
+import type { ClawMemPluginConfig, MemoryCandidate, MemorySchema, NormalizedMessage, SessionMirrorState, TranscriptSnapshot } from "./types.js";
+export declare class ConversationMirror {
+    private readonly client;
+    private readonly api;
+    private readonly config;
+    constructor(client: GitHubIssueClient, api: OpenClawPluginApi, config: ClawMemPluginConfig);
+    shouldMirror(sessionId: string, messages: NormalizedMessage[]): boolean;
+    loadSnapshot(session: SessionMirrorState, fallback: unknown[]): Promise<TranscriptSnapshot>;
+    ensureIssue(session: SessionMirrorState, snapshot: TranscriptSnapshot): Promise<void>;
+    syncBody(session: SessionMirrorState, snapshot: TranscriptSnapshot, summary: string, closed: boolean, titleOverride?: string): Promise<void>;
+    syncLabels(session: SessionMirrorState, snapshot: TranscriptSnapshot, closed: boolean): Promise<void>;
+    appendComments(issueNumber: number, messages: NormalizedMessage[]): Promise<number>;
+    generateFinalArtifacts(session: SessionMirrorState, snapshot: TranscriptSnapshot, schema?: MemorySchema): Promise<{
+        summary: string;
+        title?: string;
+        candidates: MemoryCandidate[];
+    }>;
+    private buildLabels;
+    private renderBody;
+    private resolveDates;
+    private resolveTranscriptPath;
+    private lookupBoundIssue;
+    private isBoundIssue;
+    private resetIssueBinding;
+}
+export declare function buildFinalizeArtifactsPrompt(snapshot: TranscriptSnapshot, schema?: MemorySchema): string;
+/** Derive an initial placeholder title for a new conversation. The real title is generated by LLM once enough messages are available. */
+export declare function deriveInitialTitle(_messages: NormalizedMessage[], sessionId: string): string;