myagentsBLOCK

From the repository's own README, as read at the audited commit. Badges and raw HTML are left out.

curl -fsSL https://raw.githubusercontent.com/RashadAnsari/myagents/master/install.sh | bash

myagents
✓ Download        Saved to ~/.myagents (version 65f708b).
✓ Requirements    All installed.
✓ Apps            Found Claude Code, Cursor, Codex.

albino
✓ Claude Code     Installed. Restart open sessions to load it.
✓ Cursor          Installed. Run 'De

The instruction file, verbatim from the audited commit — this is the text the model reads, and the surface the audit's instruction layer examines. Quoted here so you can judge it without cloning anything.

---
name: agent-memory
description: Use the agent-memory MCP server to retrieve, verify, and store durable project knowledge and global user knowledge before and after non-trivial work.
allowed-tools: [mcp__plugin_albino_agent-memory__project_search, mcp__plugin_albino_agent-memory__user_search, mcp__plugin_albino_agent-memory__project_remember, mcp__plugin_albino_agent-memory__user_remember, mcp__plugin_albino_agent-memory__project_update, mcp__plugin_albino_agent-memory__user_update, mcp__plugin_albino_agent-memory__project_forget, mcp__plugin_albino_agent-memory__user_forget, mcp__plugin_albino_agent-memory__project_purge, mcp__plugin_albino_agent-memory__user_purge]
---

# Project Memory & User Memory

Two parallel memory systems are available. Both are indexed notes, not authority: current user instructions, repo files, tests, and official docs always override memory.

---

## Enforcement Rules

These are hard requirements. No exceptions.

**Alternative memory systems are forbidden.** Never use the model's built-in memory, native memory tools, or any backend other than the agent-memory MCP server. This applies to every form of memory work: storing facts, recalling context, updating beliefs, retrieving preferences.

**Session bootstrap is mandatory.** Before your first response in any session, you MUST call `project_search` and `user_search` with specific terms from the current task. These calls are required, not optional. Do not respond to the user before making them. Do this silently without narrating it to the user.

**Per-turn write-back is required.** Before producing your final response each turn, ask: did I learn anything durable this turn? Durable means: a decision made, a user preference stated, a gotcha discovered, a convention established, an architecture fact clarified. If yes, you MUST call `project_remember` or `user_remember` before finishing. This is not optional. Do not skip it. Do not defer it. If nothing durable was learned this turn, skip the write, and if a stop-hook check asks the question, reply with exactly "Nothing durable learned." and finish; no explanation or summary.

---

## Quick Reference

| Question | Action |
|---|---|
| What does this user prefer? | `user_search` |
| What has been decided in this project? | `project_search` |
| Was a similar problem solved in another project? | `project_search` with `all_projects: true` |
| What is the context of a sibling / upstream / downstream repo? | `project_search` with `all_projects: true`, then read the `project_root` it belongs to |
| I learned a durable fact about a *different* repo | `project_remember` / `project_update` with that repo's `project_root` |
| Should I store this? | Only if a future agent needs it and it passes the quality rules below |
| Is this project-specific or cross-project? | This repo: `project_remember`; another repo: `project_remember` with its `project_root`; about the user everywhere: `user_remember` |

---

## User Memory

### When to Read

You MUST call user memory at the start of every session:

1. Call `user_search` with domain terms relevant to the current task (e.g. `"typescript"`, `"git workflow"`, `"testing"`).
2. Apply what you find throughout the session without being asked.

User memory is a guide, not a constraint. Explicit user instructions in the current session take precedence.

### When to Write

Write user memory when you observe something stable and cross-project about the person:

- A preference they express that is likely to apply next session too.
- A behavioral pattern you notice recurring (not just once).
- Background context that helps calibrate depth and tone.
- A global standard they apply everywhere.
- A tool or framework they consistently prefer.
- How they like to receive explanations.

Do not write:

- Anything project-specific: use `project_remember` instead.
- Secrets, credentials, API keys, or `.env` values.
- One-off opinions stated in frustration.
- Temporary task details.
- Vague notes without a clear future use.

### Quality Rules for User Memory

Every user memory must satisfy all of these:

- **Content ≥ 40 characters or ≥ 7 words.** Short notes are not durable enough.
- **No vague phrases.** Avoid "fixed the issue", "made changes", "implemented it".
- **No command output.** Do not store npm logs, test output, or exit codes.
- **No secrets.** Any content matching API key, token, or private key patterns is rejected automatically.
- **No duplicates.** Normalized content must differ from existing active memories. A duplicate raises `MemoryQualityError` (reason: `duplicates`). Do not retry: it confirms the memory already exists.

### User Memory Workflow

**At session start (mandatory):**
```
1. user_search <task-terms> → load task-relevant user knowledge
2. Apply findings silently throughout the session
```

**Before each final response (when something durable was learned):**
```
Durable = preference, gotcha, convention, behavior pattern, architecture fact
1. user_remember for each durable cross-project fact
2. source="agent" or source="user", source_ref=<context>
```

**When user memory conflicts with observed behavior:**
```
1. user_update to correct the existing memory
2. Or user_forget to archive it if it no longer applies
3. Then user_remember with the accurate version
```

---

## Project Memory

### When to Read

You MUST call project memory before any work on a codebase:

1. Call `project_search` with task-specific terms: file names, function names, domain concepts, error messages.
2. Verify findings against the actual repo before acting on them.

Memory can be stale. Always confirm what it says against current files, tests, and docs.

Do not limit yourself to the current repo. Many tasks span more than one codebase: a shared API contract, a client and its server, a monorepo split across sibling checkouts, a convention set in one repo that governs others. When the task touches another repo, or when this repo's memory is thin, call `proje

BLOCKgrade D · trust 69/100 Do not install this without reading the findings. The audit found something that could harm you or your machine.

What the source does

Filesystem

none-observed

Network

declared (5 observation(s))

Shell

none-observed

Dependencies

pinned

Secrets in source

found

Findings (15)

- Deduplicate before presenting. Never show the user the same file:line twice

assert looks_like_secret("ghp_abcdefghijklmnopqrstuvwxyzABCDEFGH")

assert looks_like_secret("-----BEGIN RSA PRIVATE KEY-----\nMIIEowIBAAK\n-----END RSA PRIVATE KEY-----")

assert looks_like_secret("-----BEGIN OPENSSH PRIVATE KEY-----\nfoobar\n-----END OPENSSH PRIVATE KEY-----")

assert looks_like_secret("xoxb-12345678901-12345678901-ABCDEFGHIJKLMNOPQRS")

assert looks_like_secret("sk_live_abcdefghijklmnopqrstuvwxyz1234567890ab")

assert looks_like_secret("sk_live_abcdefghijklmnopqrstuvwxyz1234567890ab")

You are a senior accessibility engineer and WCAG specialist. The categories below cover known accessibility failures: but accessibility expertise means reasoning about the full experience of users wit

You are a senior API design engineer with deep expertise in REST, GraphQL, and HTTP semantics. The categories below cover known API design failures: but great API design review requires reasoning abou

You are a principal software architect. The categories below document established architectural problems: but real architecture review requires reasoning about the system as a whole: how it will grow,

You are a senior software engineer with deep expertise in code quality. The categories below capture known anti-patterns: but great code review is not checklist execution. After working through every

You are a senior database engineer and schema architect. The categories below cover known database design and migration failures: but database expertise means reasoning about correctness under concurr

curl -fsSL https://raw.githubusercontent.com/RashadAnsari/myagents/master/install.sh | bash

curl -fsSL https://raw.githubusercontent.com/RashadAnsari/myagents/master/uninstall.sh | bash

curl -fsSL https://raw.githubusercontent.com/RashadAnsari/myagents/master/uninstall.sh | bash -s -- --purge

Gates applied: instruction_override, no_behavioural_pass.