@clawmem-ai/clawmem 0.1.18 → 0.1.19

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "clawmem",
   "name": "ClawMem",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "description": "Repo-backed long-term memory plugin for OpenClaw with auto recall, durable memory capture, and conversation mirroring.",
   "kind": "memory",
   "skills": [
@@ -43,6 +43,10 @@
               "type": "string",
               "minLength": 1
             },
+            "login": {
+              "type": "string",
+              "minLength": 1
+            },
             "defaultRepo": {
               "type": "string",
               "pattern": "^[^/]+/[^/]+$"
@@ -81,6 +85,11 @@
         "type": "integer",
         "minimum": 1,
         "maximum": 20
+      },
+      "reviewNudgeInterval": {
+        "type": "integer",
+        "minimum": 0,
+        "maximum": 100
       }
     }
   },
@@ -128,6 +137,10 @@
     "memoryAutoRecallLimit": {
       "label": "Auto Recall Limit",
       "help": "Maximum number of active memories automatically injected before each turn."
+    },
+    "reviewNudgeInterval": {
+      "label": "Review Nudge Interval",
+      "help": "How many user turns pass before ClawMem injects a <clawmem-review-nudge> reminder for the agent to run the review protocol. Set to 0 to disable. Default 10."
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawmem-ai/clawmem",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "description": "Repo-backed long-term memory plugin for OpenClaw with auto recall, durable memory capture, and conversation mirroring.",
   "type": "module",
   "license": "MIT",
@@ -18,23 +18,37 @@
     "type": "git",
     "url": "git+https://github.com/clawmem-ai/clawmem-openclaw-plugin.git"
   },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "files": [
-    "index.ts",
+    "dist",
     "openclaw.plugin.json",
-    "src",
     "skills",
-    "README.md",
-    "tsconfig.json"
+    "README.md"
   ],
   "exports": {
-    ".": "./index.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
+    "build": "tsc -p tsconfig.json",
+    "prepack": "npm run clean && npm run build",
+    "test": "tsx src/collaboration.test.ts && tsx src/config.test.ts && tsx src/conversation.test.ts && tsx src/github-client.test.ts && tsx src/memory.test.ts && tsx src/service.test.ts && tsx src/state.test.ts"
   },
   "publishConfig": {
     "access": "public"
   },
   "openclaw": {
     "extensions": [
-      "./index.ts"
+      "./dist/index.js"
     ]
+  },
+  "devDependencies": {
+    "@types/node": "^24.12.3",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.3"
   }
 }

package/skills/clawmem/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: clawmem
-description: Durable memory workflows for the ClawMem OpenClaw plugin. Use when ClawMem is installed and you need to recall prior preferences, project history, facts, decisions, lessons, workflows, active tasks, or shared/team memory; save or update durable knowledge with the ClawMem memory tools; choose the right memory repo; manage shared memory spaces, organizations, teams, collaborators, invitations, outside collaborators, or repo-access governance in the ClawMem backend; or troubleshoot ClawMem setup and manual repo-backed operations.
+description: Durable memory workflows for the ClawMem OpenClaw plugin. Use when ClawMem is installed and you need to recall prior preferences, project history, facts, decisions, lessons, workflows, active tasks, or shared memory; save or update durable knowledge with the ClawMem memory tools; choose the right memory repo; manage shared memory spaces, organizations, teams, collaborators, invitations, outside collaborators, or repo-access governance in the ClawMem backend; or troubleshoot ClawMem setup and manual repo-backed operations.
 ---
 
 # ClawMem
@@ -28,6 +28,7 @@ The ClawMem plugin automatically handles:
 - Best-effort automatic memory recall before each turn, scoped to the current agent's `defaultRepo`
 - A best-effort final issue summary/title plus durable memory capture when the session resets or ends normally
 - Mid-session memory tools: `memory_repos`, `memory_repo_create`, `memory_list`, `memory_get`, `memory_labels`, `memory_recall`, `memory_store`, `memory_update`, and `memory_forget`
+- Shared-workflow tools for collaboration routing, default repo retargeting, generic issues, and issue comments
 
 ## Mandatory turn loop
 
@@ -36,8 +37,8 @@ On every user turn, run this loop:
 1. Before answering, ask: could ClawMem improve this answer?
    - Default to yes for user preferences, project history, prior decisions, lessons, conventions, terminology, recurring problems, and active tasks.
    - Auto-recall may already inject useful context from the current agent's `defaultRepo`, but it is only a hint. Do not treat missing auto-recall context as proof that no relevant memory exists.
-   - If the injected context already answers the question, you do not need to immediately call `memory_recall` again.
-   - Auto-recall does not currently fan out across every accessible repo. Shared organization memory, team memory, and project memory outside the current `defaultRepo` will not be recalled automatically.
+   - Each `<clawmem-context>` bullet is `- [id] (kind:<kind>) <title> — <detail>` when those fields are available. Use the `kind` to triage: prefer `kind:skill` / `kind:convention` as operational guidance, and treat `kind:lesson` as one-off corrections unless several converge on the same direction (then promote — see [references/review.md](references/review.md)).
+   - Auto-recall does not currently fan out across every accessible repo. Shared organization memory and project memory outside the current `defaultRepo` will not be recalled automatically.
    - Before explicit memory work, choose the right repo. If unclear, inspect `memory_repos` and fall back to the agent's `defaultRepo`. If the likely memory lives outside the default repo, use explicit repo selection instead of relying on auto-recall.
    - Use `memory_recall` when injected context is missing, weak, cross-repo, high-stakes, or when you need an explicit retrieval trace.
    - Write `memory_recall.query` as a short natural-language intent. Do not paste long code blocks, full logs, tool chatter, or system prompt text unless the exact wording is necessary.
@@ -58,7 +59,25 @@ On every user turn, run this loop:
    - Keep one durable fact per memory. Do not bundle unrelated facts, temporary requests, tool chatter, or startup boilerplate into one saved node.
    - For new memories, write the memory title and body in the user's current language by default.
    - Use `memory_forget` when a memory is stale, superseded, or harmful if reused.
-3. Keep the user posted.
+   - Trigger-phrase reflex: when the user's message contains one of the signals below, writing memory is not optional — pick the indicated kind and save, or `memory_update` the canonical node if one already exists.
+
+     | Signal from the user | Kind to save |
+     |---|---|
+     | "no", "don't", "stop doing that", "下次不要这样", "别这样", an explicit correction, an apology accepted after a mistake | `kind:lesson` |
+     | "yes exactly", "perfect, keep doing that", "这就是我要的", validation of a non-obvious choice you made | `kind:lesson` (what worked and why) or `kind:skill` if it was a multi-step procedure |
+     | "always / never", "from now on", "as a rule", naming/style/tool preferences, agreed policies | `kind:convention` |
+     | Identity, role, long-term goal, team, stable project fact, unchanging constraint | `kind:core-fact` |
+     | A non-trivial procedure that succeeded (several tool calls, trial and error, course changes) or one the user explicitly asks you to remember | `kind:skill` |
+     | Ongoing work that will be referenced across turns or sessions | `kind:task` |
+
+     If two or more `kind:lesson` memories start pointing at the same corrective direction, promote them to one `kind:skill` and close the originals with `superseded-by: #N` in the body — see [references/review.md](references/review.md).
+   - "Skill" in this skill always means a ClawMem `kind:skill` memory — an issue written through `memory_store` / `memory_update` using the YAML body template in [references/schema.md § Skill body template](references/schema.md#skill-body-template-kindskill). When the user says "沉淀成 skill", "存成 skill", "记住这个流程", "remember this procedure", or similar, they mean a `kind:skill` memory, not a file-based skill package. Do not invoke the file-based `skill-creator` or write `skills/<name>/SKILL.md` in response to these phrases. Only generate a file-based skill package when the user explicitly asks for one ("打包成 skill 文件", "make a skill package", naming an on-disk path).
+   - Before your first `memory_store` with `kind:skill` in a session, read [references/schema.md § Skill body template](references/schema.md#skill-body-template-kindskill) and write the initial `detail` body using that YAML skeleton (`trigger` / `steps` / `checks` / `last_validated` / `evidence`). Do not save the skill as free-form prose and plan to "clean it up later" — the first save should already be in the canonical shape so future `memory_update` calls can refine it in place.
+3. Periodically self-review.
+   - Every ~8–10 user turns, after a completed task, or when a `<clawmem-review-nudge>` block appears in context, run the review protocol in [references/review.md](references/review.md) before the next turn completes.
+   - The `memory_review` tool returns the latest review checklist. Call it when you want a compact reminder of what to look for, or when the user explicitly asks for a memory or skill review.
+   - Review is where `kind:skill` and `kind:lesson` actually accumulate; do not rely on session finalization alone.
+4. Keep the user posted.
    - If a retrieved memory materially shaped the answer, briefly surface that fact in the user's current language.
    - Include the memory id and title only when they help with debugging, traceability, or an explicit user request.
    - After creating or updating a memory, give a short confirmation in the user's current language instead of forcing fixed English phrasing.
@@ -80,13 +99,15 @@ Bias toward saving, and use explicit retrieval whenever auto-recall is absent, w
 - When updating an existing memory, keep that node in its current language unless the user explicitly asks to rewrite it.
 - Keep schema labels and machine-oriented fields stable. Do not translate `type:*`, `kind:*`, `topic:*`, or other structural identifiers.
 - If the user is asking about collaboration, organizations, teams, invitations, collaborators, shared repo access, or why someone can or cannot access a memory repo, switch from normal memory reasoning to the collaboration workflow in `references/collaboration.md`.
+- If the user wants Team design, Team setup, or a Team workflow template, use an external ClawMem Team skill pack such as `clawmem-team-skills` instead of inventing an in-plugin workflow.
 
 ## Read the right reference
 
 - For user-facing runtime messaging, memory console links, and post-save confirmations, read [references/communication.md](references/communication.md).
 - For activation repair, route verification, tool-path verification, and compatibility-file reminders after install, read [references/repair.md](references/repair.md).
 - For shared repos, team memory, organizations, teams, invitations, collaborators, and collaboration routing, read [references/collaboration.md](references/collaboration.md).
-- For memory kinds, labels, curated versus plugin-managed nodes, and when to use each shape, read [references/schema.md](references/schema.md).
+- For memory kinds, labels, curated versus plugin-managed nodes, the `kind:skill` body template, and when to use each shape, read [references/schema.md](references/schema.md).
+- For the periodic self-review protocol (memory + skill tracks, lesson-to-skill promotion, anti-patterns), read [references/review.md](references/review.md).
 - For raw `gh` or `curl` flows, route resolution, troubleshooting, and `git push` to ClawMem, read [references/manual-ops.md](references/manual-ops.md).
 
 ## Bundled script

package/skills/clawmem/references/collaboration.md

@@ -41,7 +41,7 @@ Do not use this workflow for ordinary memory recall or save actions unless the u
 - Prefer the built-in ClawMem collaboration tools first.
 - Inspect current state before mutating anything.
 - Set `confirmed=true` only after the user has approved the exact org, team, repo, invitation, or permission change.
-- Fall back to `gh api` or `curl` only when plugin tools are unavailable, when debugging backend behavior directly, or when you must create an org-owned repo because the plugin does not expose an org-repo creation tool yet.
+- Fall back to `gh api` or `curl` only when plugin tools are unavailable or when debugging backend behavior directly.
 - Reuse the main `clawmem` skill's route-resolution helper when raw shell access is required.
 - Think in canonical runtime permissions: `read`, `write`, `admin`.
 - Treat GitHub-compatible aliases such as `pull`, `triage`, `push`, and `maintain` as transport compatibility only.
@@ -64,6 +64,7 @@ Tool-first rule:
   - `collaboration_repo_access_inspect`
 - Mutations:
   - `collaboration_org_create`
+  - `collaboration_org_repo_create`
   - `collaboration_org_member_remove`
   - `collaboration_org_membership_remove`
   - `collaboration_team_create`
@@ -96,7 +97,8 @@ Do not treat `defaultRepo` as the only space. It is only the fallback.
 Default tool path:
 - Use `memory_repos` to inspect accessible spaces
 - Use `memory_repo_create` when a new repo should be owned by the current agent identity
-- Create an org-owned repo with raw `gh api` or `curl` when the memory space must be governed by an organization team
+- Use `collaboration_org_repo_create` when the memory space must be governed by an organization team
+- Use `memory_repo_set_default` when a repo move or routing change should update the current agent's automatic default
 - Pass `repo` explicitly to `memory_recall`, `memory_list`, `memory_get`, `memory_store`, `memory_update`, and `memory_forget` when the target is not the current `defaultRepo`
 
 This keeps private memory, project memory, and shared memory separate without forcing extra plugin configuration changes.
@@ -131,7 +133,7 @@ Use this decision map:
 | Bring one user into the org | Org invitation |
 | Inspect whether a user already has org membership or only a pending org invite | Org membership inspection |
 | Grant a group access to selected repos | Team + team-repo grant |
-| Create a shared team memory space | Org-owned repo + team-repo grant |
+| Create a shared team memory space | `collaboration_org_repo_create` + team-repo grant |
 | Move an existing memory repo under org governance | Repo transfer into org |
 | Create another memory space under the current agent identity | `memory_repo_create` |
 | Inspect non-members who still have repo access | Outside collaborator listing |
@@ -160,7 +162,7 @@ Translate user intent like this:
 
 - `Create a shared memory repo for team X`
   - inspect or create the org and team first
-  - if the repo should be team-governed, create an org-owned repo with raw `gh api` or `curl`; `memory_repo_create` only creates repos under the current agent identity
+  - if the repo should be team-governed, use `collaboration_org_repo_create`; `memory_repo_create` only creates repos under the current agent identity
   - grant the team access with `collaboration_team_repo_set`
 - `Give Alice access to this one memory repo`
   - inspect direct collaborators first with `collaboration_repo_collaborators`
@@ -187,6 +189,7 @@ Translate user intent like this:
 - `Move this repo into org acme so team access can govern it`
   - ensure the target org already exists and the actor has org admin rights
   - then use `collaboration_repo_transfer`
+  - if the moved repo was the current agent's `defaultRepo`, expect the plugin to retarget `defaultRepo` automatically; otherwise use `memory_repo_set_default` explicitly when needed
 - `Someone shared a memory repo with me; can you see it and accept it?`
   - start with `collaboration_user_repo_invitations`
   - do not treat a `memory_repos` miss as proof that no share exists
@@ -218,7 +221,11 @@ If knowledge should stay personal, keep it in the agent's default repo. If it sh
 
 ## Manual org-owned shared repo creation
 
-Use the plugin tool path first. If the memory space must be org-governed, create an org-owned repo directly because `memory_repo_create` only creates repos under the current agent identity.
+Use the plugin tool path first:
+
+- Prefer `collaboration_org_repo_create` for normal org-owned repo creation.
+- Use raw `gh api` or `curl` only when plugin tools are unavailable or when debugging backend behavior directly.
+- `memory_repo_create` still only creates repos under the current agent identity.
 
 ### With `gh api`
 
@@ -246,6 +253,7 @@ After the repo exists:
 
 If the repo already exists under a personal owner and should become org-governed instead of creating a fresh repo:
 - use `collaboration_repo_transfer`
+- if that repo was the acting agent's `defaultRepo`, the plugin retargets `defaultRepo` automatically after a successful transfer
 - then continue with team grants and explicit `repo` targeting against the new org-owned full name
 
 ## Fallback mode

package/skills/clawmem/references/review.md

@@ -0,0 +1,77 @@
+# ClawMem Review Protocol
+
+This reference describes the periodic self-review loop that keeps ClawMem memory from drifting. The normal turn loop in [SKILL.md](../SKILL.md) is reactive; review is deliberate. Run it so that lessons, conventions, and skills actually accumulate instead of being silently dropped at session boundaries.
+
+## When to run a review
+
+Run a review when any of the following is true:
+
+- You have completed roughly 8–10 user turns since the last review, or since the start of the session.
+- You just finished a multi-step task, a non-trivial tool chain, or a workflow the user validated.
+- The user signaled satisfaction ("yes exactly", "perfect", "这就是我要的") or issued a correction ("no", "don't", "下次不要这样").
+- The plugin injected a review nudge via `<clawmem-review-nudge>` in the prompt context.
+- You are about to return control to the user at the end of a session, or a `before_reset` / `session_end` is imminent.
+- The agent has the `memory_review` tool available and the user explicitly asks for a memory or skill review.
+
+Running once more than needed is fine. Skipping it for a session is not.
+
+## Running the review
+
+A review has two independent tracks. Run both.
+
+### Track A — Memory review
+
+Ask yourself, about the conversation since the last review:
+
+1. **User signals** — Did the user reveal identity, role, preferences, habits, goals, or constraints I have not yet stored?
+2. **Expectations** — Did the user express how they want me to behave, communicate, format output, choose tools, or avoid specific pitfalls?
+3. **Corrections** — Did the user push back on an answer or an approach? What should I never repeat? What should I do instead next time?
+4. **Validations** — Did the user confirm that a non-obvious choice was the right one? That is also worth saving, because corrections alone make you timid.
+5. **Stale beliefs** — Did this turn invalidate a memory I recalled or would have recalled? Candidates for `memory_forget` or `memory_update`.
+6. **Cross-repo hints** — Did anything belong in a project repo or a shared team repo rather than `defaultRepo`?
+
+For each positive answer, pick one of:
+- `memory_update` on an existing canonical node if one already covers the topic.
+- `memory_store` with a deliberate `kind` (and topics) if it is a genuinely new fact.
+- `memory_forget` to retire the stale one.
+
+Prefer one atomic fact per write. Do not bundle.
+
+### Track B — Skill review
+
+Ask yourself:
+
+1. Was a non-trivial approach used to finish a task — one that required trial and error, changing course, or recovering from errors?
+2. Did a specific sequence of tool calls or decisions lead to a good result that would have been hard to derive from scratch?
+3. Did the user describe a procedure I should follow in the future?
+4. Is there an existing `kind:skill` memory that this turn either confirmed, refined, or contradicted?
+
+If yes on 1–3 and no matching `kind:skill` exists, write a new one using the canonical YAML shape in [schema.md § Skill body template](schema.md#skill-body-template-kindskill).
+
+If yes on 4, `memory_update` the existing skill:
+- Bump `last_validated` to today's date.
+- Append the new supporting conversation or memory id to `evidence`.
+- Refine `steps` / `checks` if the turn produced a better formulation.
+- If the turn contradicted the skill, either fix it in place or close the memory and create a replacement that references the old id with `superseded-by`.
+
+### Lesson → Skill promotion
+
+If you find two or more active `kind:lesson` memories pointing at the same corrective direction on the same topic, promote them:
+
+1. Write one `kind:skill` that captures the positive behavior (what to do), not just the prohibitions.
+2. Close the source lessons with a body note like `superseded-by: #<new-skill-id>`.
+3. Leave one lesson open if it captures a specific failure worth remembering on its own.
+
+## After the review
+
+- Give a short confirmation to the user in their current language, naming what was saved, updated, or retired. Example: "已沉淀 1 条 skill、更新 1 条 convention、归档 1 条过期 lesson。"
+- If nothing was worth writing, say so briefly rather than saying nothing — the user needs to know the review ran.
+- Reset your internal "turns since last review" counter.
+
+## Review anti-patterns
+
+- Saving a play-by-play of the session. That belongs in the `type:conversation` issue, not in durable memory.
+- Saving every tool invocation as a skill. Skills are for non-trivial, reusable procedures.
+- Creating a new `kind:lesson` every time the user nudges phrasing. Trivial style tweaks usually belong in an existing `kind:convention` via `memory_update`.
+- Rewriting a memory from scratch when a small `memory_update` would do.
+- Running only the memory track and skipping the skill track because "nothing seemed worth a skill". Ask the question; do not skip it.

package/skills/clawmem/references/schema.md

@@ -57,7 +57,50 @@ If you create a curated memory manually, include:
 - If the current schema does not fit and a new label would help future retrieval, coordination, or reuse, create one deliberate new machine-readable label.
 - Do not create translated variants or near-duplicate synonyms of an existing label. Prefer reuse first, then one canonical new label if needed.
 - 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:*`.
+- For plugin-managed memory schema, do not invent random label prefixes. Memory schema evolution must stay within `kind:*` and `topic:*`.
+
+## Update vs new: the node-evolution rule
+
+Durable knowledge evolves by updating canonical nodes, not by spawning near-duplicates.
+
+- Before `memory_store`, `memory_recall` the same topic. If an open memory already covers the same fact, decision, workflow, or policy, use `memory_update` instead. Only open a new node when the new fact is semantically orthogonal to every existing canonical node.
+- When updating, preserve the node's original language unless the user explicitly asks for a rewrite. Refine the `detail` in place, tighten `title`, and add topic labels as coverage expands.
+- When a memory is contradicted by the current turn, choose one of:
+  - `memory_update` to record the new canonical truth on the existing node,
+  - `memory_forget` (close the issue) if the fact is simply no longer true and has no replacement,
+  - or open a new node and close the old one with a body note `superseded-by: #<new-id>` when the semantics are now different enough that one node cannot carry both.
+- Lesson → Skill promotion: when two or more active `kind:lesson` nodes point at the same corrective direction on the same topic, write one `kind:skill` that captures the positive behavior and close the lessons with `superseded-by: #<new-skill-id>`. Keep a single lesson open only if it captures a specific failure worth remembering on its own.
+- Re-validation: when `memory_recall` surfaces a `kind:skill` or `kind:convention` and the current turn re-confirms or re-applies it, `memory_update` to bump the `last_validated` date in the body (see template below) and append the turn's conversation id to `evidence`. Silent success erodes confidence in old nodes.
+
+## Skill body template (`kind:skill`)
+
+In ClawMem, a "skill" is a `kind:skill` memory — an issue written through `memory_store` / `memory_update`. It is not a file-based skill package (`skills/<name>/SKILL.md`), and the ClawMem turn loop never triggers a file-based skill-creator. When the user says "沉淀成 skill", "存成 skill", or "remember this procedure", write the memory here using the template below. Only produce an on-disk skill package when the user explicitly asks for one.
+
+`kind:skill` memories are playbooks and are meant to be re-used and re-updated many times. Give them a stable YAML-on-top body so they remain readable and mergeable. Read this section before your first `memory_store` with `kind:skill` and shape the initial `detail` body using this skeleton — don't save as prose and plan to refactor later.
+
+```yaml
+trigger: When this skill applies — the user request shape or situation that should cue it.
+steps:
+  - First action, concrete enough to follow without re-deriving.
+  - Next action.
+  - Final action.
+checks:
+  - Signals that the skill succeeded.
+  - Signals that the skill is the wrong fit and you should stop.
+last_validated: 2026-04-20
+evidence:
+  - "#42"   # conversation issue or memory id that supports this skill
+  - "#77"
+```
+
+Narrative prose, caveats, and references can follow the YAML block in the same body. The YAML block itself stays flat (no nested maps beyond lists), which matches ClawMem's body parser.
+
+When a `kind:skill` is re-used successfully, `memory_update` to:
+- bump `last_validated` to today's date,
+- append the latest supporting id to `evidence`,
+- refine `steps` or `checks` only if the turn produced a clearly better formulation.
+
+When a `kind:skill` fails in use, either fix `steps` / `checks` in place or close the node and open a replacement that references the old id with `superseded-by`.
 
 ## Storage language
 

package/index.ts

@@ -1,6 +0,0 @@
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
-import { createClawMemPlugin } from "./src/service.js";
-
-export default function register(api: OpenClawPluginApi) {
-  createClawMemPlugin(api);
-}

package/src/collaboration.test.ts

@@ -1,71 +0,0 @@
-import {
-  filterDirectCollaborators,
-  listRepoAccessTeams,
-  repoSummaryFullName,
-  resolveOrgInvitationRole,
-} from "./collaboration.js";
-
-function assert(condition: unknown, message: string): void {
-  if (!condition) throw new Error(message);
-}
-
-function testOrgInvitationRoleValidation(): void {
-  const fallback = resolveOrgInvitationRole(undefined, "member");
-  assert("role" in fallback && fallback.role === "member", "expected undefined role to fall back to member");
-
-  const owner = resolveOrgInvitationRole("owner", "member");
-  assert("role" in owner && owner.role === "owner", "expected owner role to pass through");
-
-  const invalid = resolveOrgInvitationRole("admin", "member");
-  assert("error" in invalid, "expected admin to be rejected because backend expects owner");
-}
-
-function testDirectCollaboratorFiltering(): void {
-  const collaborators = filterDirectCollaborators([
-    { login: "Acme" },
-    { login: "alice", outside_collaborator: true },
-    { login: "bob", organization_member: true },
-  ], "acme");
-
-  assert(collaborators.length === 2, "expected owner row to be excluded from explicit collaborators");
-  assert(collaborators[0]?.login === "alice", "expected alice to remain after owner filtering");
-  assert(collaborators[1]?.login === "bob", "expected bob to remain after owner filtering");
-}
-
-function testRepoSummaryFallback(): void {
-  assert(repoSummaryFullName({ full_name: "acme/project" }) === "acme/project", "expected explicit full_name to win");
-  assert(repoSummaryFullName({ owner: { login: "acme" }, name: "project" }) === "acme/project", "expected owner/name fallback to work");
-}
-
-async function testRepoAccessTeamsDerivation(): Promise<void> {
-  const result = await listRepoAccessTeams({
-    async listOrgTeams() {
-      return [
-        { slug: "admins", name: "admins" },
-        { slug: "writers", name: "writers" },
-        { slug: "broken", name: "broken" },
-      ];
-    },
-    async listTeamRepos(_org: string, teamSlug: string) {
-      if (teamSlug === "admins") return [{ full_name: "acme/project", role_name: "admin" }];
-      if (teamSlug === "writers") return [{ owner: { login: "acme" }, name: "project", role_name: "write" }];
-      if (teamSlug === "broken") throw new Error("boom");
-      return [];
-    },
-  }, "acme", "acme/project");
-
-  assert(result.teams.length === 2, "expected two teams with access to be discovered via org->team->repo traversal");
-  assert(result.teams[0]?.slug === "admins", "expected admins team to be included");
-  assert(result.teams[1]?.slug === "writers", "expected writers team to be included");
-  assert(result.notes.length === 1 && result.notes[0]?.includes("broken"), "expected per-team lookup failures to be recorded as notes");
-}
-
-async function main(): Promise<void> {
-  testOrgInvitationRoleValidation();
-  testDirectCollaboratorFiltering();
-  testRepoSummaryFallback();
-  await testRepoAccessTeamsDerivation();
-  console.log("collaboration tests passed");
-}
-
-await main();

package/src/collaboration.ts

@@ -1,109 +0,0 @@
-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 function normalizePermissionAlias(value: unknown): "none" | CollaborationPermission | undefined {
-  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: unknown,
-  fallback: CollaborationOrgInvitationRole,
-): { role: CollaborationOrgInvitationRole } | { error: string } {
-  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?: CollaborationRepoSummary): string | undefined {
-  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: CollaborationCollaboratorSummary[],
-  ownerLogin: string,
-): CollaborationCollaboratorSummary[] {
-  const owner = ownerLogin.trim().toLowerCase();
-  if (!owner) return collaborators;
-  return collaborators.filter((collaborator) => (collaborator.login?.trim().toLowerCase() || "") !== owner);
-}
-
-export async function listRepoAccessTeams(
-  client: RepoAccessTeamClient,
-  org: string,
-  fullName: string,
-): Promise<{ teams: CollaborationTeamSummary[]; notes: string[] }> {
-  const notes: string[] = [];
-  const teams = await client.listOrgTeams(org);
-  const withAccess: CollaborationTeamSummary[] = [];
-  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/src/config.test.ts

@@ -1,83 +0,0 @@
-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,
-    memoryAutoRecallLimit: 3,
-    summaryWaitTimeoutMs: 120000,
-    memoryExtractWaitTimeoutMs: 45000,
-  };
-}
-
-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");