shieldcortex 2.4.0 → 2.4.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/README.md +166 -286
  2. package/dist/index.js +0 -0
  3. package/package.json +16 -8
package/README.md CHANGED
@@ -4,370 +4,250 @@
4
4
  [![npm downloads](https://img.shields.io/npm/dm/shieldcortex.svg)](https://www.npmjs.com/package/shieldcortex)
5
5
  [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
6
6
 
7
- **The security layer for any AI agent's memory.** Like Cloudflare, but for everything your AI remembers — regardless of platform.
7
+ ## 🧠 + 🛡️ Complete Memory & Security for AI Agents
8
8
 
9
- Researchers have [demonstrated persistent memory attacks](https://embracethered.com/blog/posts/2024/chatgpt-hacking-memories/) on AI agents. Attackers can poison what your agent remembers — injecting instructions, stealing credentials, or assembling attacks across days of fragmented memories. **ShieldCortex stops that.**
9
+ **ShieldCortex gives your AI agent persistent memory AND protects it from attack. One package. Full solution.**
10
10
 
11
- ### Supported Agents
11
+ Most AI agents are stateless — they forget everything between sessions. ShieldCortex fixes that with production-grade persistent memory. But memory creates risk: researchers have [demonstrated memory poisoning attacks](https://embracethered.com/blog/posts/2024/chatgpt-hacking-memories/) that hijack AI behaviour. **ShieldCortex is the only solution that solves both problems.**
12
12
 
13
- ShieldCortex is agent-agnostic middleware. It works with:
14
-
15
- - **[Claude Code](https://claude.ai)** — Native MCP server + hooks (`npx shieldcortex setup`)
16
- - **[OpenClaw / Moltbook](https://openclaw.dev)** — Native hook support (`npx shieldcortex clawdbot install`)
17
- - **[LangChain JS](https://js.langchain.com)** — `ShieldCortexMemory` adapter (`import { ShieldCortexMemory } from 'shieldcortex/integrations/langchain'`)
18
- - **Python frameworks (CrewAI, AutoGPT, etc.)** — Via REST API (`POST /api/v1/scan`)
19
- - **Any MCP-compatible agent** — Via `@langchain/mcp-adapters` or direct MCP protocol
20
- - **Any agent with a memory backend** — REST API for scanning, quarantine, and audit
21
-
22
- If your agent stores memories, ShieldCortex can protect them.
23
-
24
- ---
25
-
26
- ## Is Your AI Agent Compromised?
27
-
28
- Find out in 30 seconds:
29
-
30
- ```bash
31
- npx shieldcortex setup
32
13
  ```
33
-
34
- Then ask your AI agent: **"Scan my memories for threats"**
35
-
36
- ShieldCortex will scan every stored memory and report:
37
- - Hidden instructions disguised as normal content
38
- - Credential harvesting attempts
39
- - Encoded payloads (base64, unicode tricks, hex)
40
- - Fragmented attack patterns spread across multiple memories
41
- - Privilege escalation attempts
42
-
43
- **No threats found?** Great — now you're protected going forward too.
44
-
45
- ---
46
-
47
- ## What It Does
48
-
49
- ShieldCortex is a defence pipeline that sits between AI agents and their memory:
50
-
51
- ```
52
- Agent → ShieldCortex → Any Memory Backend
53
- ↓
54
- Scan → Score → Classify → Audit
14
+ ┌─────────────────────────────────────────────────────────────┐
15
+ │ ShieldCortex │
16
+ ├─────────────────────────────┬───────────────────────────────┤
17
+ │ 🧠 MEMORY SYSTEM │ 🛡️ SECURITY LAYER │
18
+ ├─────────────────────────────┼───────────────────────────────┤
19
+ │ • Persistent storage │ • Memory firewall │
20
+ │ • Semantic search │ • Prompt injection detection │
21
+ │ • Project scoping │ • Credential protection │
22
+ │ • Importance ranking │ • Sub-agent access control │
23
+ │ • Auto-cleanup & decay │ • Full audit trail │
24
+ │ • Category organisation │ • Threat quarantine │
25
+ └─────────────────────────────┴───────────────────────────────┘
55
26
  ```
56
27
 
57
- Every memory write is scanned. Every memory read is filtered. Everything is logged.
28
+ **Stop choosing between memory and security. Get both.**
58
29
 
59
- ### Defence Layers
30
+ ---
60
31
 
61
- | Layer | What It Catches | Tier |
62
- |-------|----------------|------|
63
- | **Memory Firewall** | Prompt injection, hidden instructions, encoding tricks, command injection | Free |
32
+ ## What You Get
33
+
34
+ ### 🧠 Memory System (Production-Ready)
35
+ - **Persistent storage** — SQLite-backed, survives restarts
36
+ - **Semantic search** — Find memories by meaning, not just keywords
37
+ - **Project scoping** — Isolate memories per project/context
38
+ - **Importance levels** — Critical, high, normal, low with auto-decay
39
+ - **Categories** — Architecture, decisions, preferences, context, learnings
40
+ - **Auto-cleanup** — Configurable retention, importance-based expiry
41
+ - **Full MCP support** — Works with any MCP-compatible agent
42
+
43
+ ### 🛡️ Security Layer (5 Defence Layers)
44
+ | Layer | What It Does | Tier |
45
+ |-------|-------------|------|
46
+ | **Memory Firewall** | Blocks prompt injection, encoding tricks, hidden instructions | Free |
64
47
  | **Audit Logger** | Full forensic trail of every memory operation | Free |
65
- | **Trust Scorer** | Filters memories by source reliability — agent hierarchy with 0.7× decay per level | Free |
66
- | **Sub-Agent Security** | Access control, rate limiting, auto-quarantine for untrusted agents | Free |
67
- | **Sensitivity Classifier** | Detects passwords, API keys, PII — auto-redacts on recall | Pro |
68
- | **Fragmentation Detector** | Catches multi-step assembly attacks spread across days | Pro |
69
-
70
- ### Attack Vectors Blocked
71
-
72
- 1. **Direct injection** — `[SYSTEM: ignore previous instructions]` hidden in memory content
73
- 2. **Credential harvesting** — Memories that try to exfiltrate API keys or passwords
74
- 3. **Encoding tricks** — Base64/hex/unicode payloads that bypass text filters
75
- 4. **Slow-burn assembly** — Attack fragments planted over days that combine into a full exploit
76
- 5. **Privilege escalation** — Memories referencing system commands, file paths, or admin URLs
48
+ | **Trust Scorer** | Scores memories by source reliability | Free |
49
+ | **Sub-Agent Security** | Access control, rate limiting, auto-quarantine | Free |
50
+ | **Sensitivity Classifier** | Detects & redacts passwords, API keys, PII | Pro |
51
+ | **Fragmentation Detector** | Catches slow-burn assembly attacks | Pro |
52
+
53
+ ### 🎯 Attack Vectors Blocked
54
+ - **Direct injection** — `[SYSTEM: ignore previous]` hidden in content
55
+ - **Credential harvesting** — Attempts to exfiltrate secrets
56
+ - **Encoding tricks** — Base64/hex/unicode payloads
57
+ - **Slow-burn assembly** — Attack fragments planted over days
58
+ - **Privilege escalation** — System command references
77
59
 
78
60
  ---
79
61
 
80
- ## Quick Start
81
-
82
- ### Fresh Install
62
+ ## Quick Start (30 Seconds)
83
63
 
84
64
  ```bash
85
- # Install
65
+ # Install globally
86
66
  npm install -g shieldcortex
87
67
 
88
- # Auto-detect your agent and configure (works with Claude Code, OpenClaw, and more)
68
+ # Auto-configure for your agent (Claude Code, OpenClaw, LangChain, etc.)
89
69
  npx shieldcortex setup
90
70
 
91
- # Restart your agent and approve the MCP server
71
+ # That's it. Your agent now has persistent memory + security.
92
72
  ```
93
73
 
94
- ### Migrating from Claude Cortex
95
-
74
+ **Already using Claude Cortex?** Migrate in one command:
96
75
  ```bash
97
- # Non-destructive — copies your database, updates settings
98
76
  npx shieldcortex migrate
99
-
100
- # Restart your agent
101
- ```
102
-
103
- Your existing memories are preserved. The original database stays intact at `~/.claude-cortex/` for rollback.
104
-
105
- ### Verify Installation
106
-
107
- ```bash
108
- npx shieldcortex doctor
109
77
  ```
110
78
 
111
79
  ---
112
80
 
113
- ## How It Works
114
-
115
- ### Automatic Memory (via Hooks)
116
-
117
- When you run `npx shieldcortex setup`, three hooks are installed:
118
-
119
- | Hook | Fires When | What It Does |
120
- |------|-----------|--------------|
121
- | **SessionStart** | Session begins | Loads project context from memory |
122
- | **PreCompact** | Before context compaction | Extracts important content before it's lost |
123
- | **SessionEnd** | Session exits | Saves decisions, fixes, and learnings |
81
+ ## Supported Agents
124
82
 
125
- **What gets auto-extracted:**
126
- - Decisions: "decided to...", "going with...", "chose..."
127
- - Error fixes: "fixed by...", "the solution was...", "root cause..."
128
- - Learnings: "learned that...", "discovered...", "turns out..."
129
- - Architecture: "the architecture uses...", "design pattern..."
83
+ ShieldCortex is agent-agnostic middleware:
130
84
 
131
- ### Brain-Like Memory Model
85
+ | Agent | Integration |
86
+ |-------|-------------|
87
+ | **[Claude Code](https://claude.ai)** | `npx shieldcortex setup` — Native MCP server |
88
+ | **[OpenClaw](https://openclaw.ai)** | `npx shieldcortex clawdbot install` — Native hooks |
89
+ | **[LangChain JS](https://js.langchain.com)** | `import { ShieldCortexMemory } from 'shieldcortex/integrations/langchain'` |
90
+ | **Python (CrewAI, AutoGPT)** | REST API — `POST /api/v1/scan` |
91
+ | **Any MCP agent** | Via MCP protocol or `@langchain/mcp-adapters` |
132
92
 
133
- ShieldCortex doesn't just store text — it thinks like a brain:
134
-
135
- - **Short-term → Long-term** promotion based on access frequency
136
- - **Salience detection** — auto-scores what's worth keeping
137
- - **Temporal decay** — unused memories fade, accessed memories strengthen
138
- - **Knowledge graph** — entities and relationships extracted automatically
139
-
140
- ### Defence Pipeline
141
-
142
- Every `addMemory()` call runs through the defence pipeline:
143
-
144
- 1. **Trust scoring** — source gets a trust score (user=1.0, CLI=0.9, agents=hierarchy-based with 0.7× decay)
145
- 2. **Firewall scan** — content checked for injection, encoding, privilege escalation
146
- 3. **Sensitivity classification** — detects secrets, PII, credentials
147
- 4. **Fragmentation analysis** — cross-references with recent memories for assembly patterns
148
- 5. **Access control** — sub-agents auto-quarantined, rate-limited (20 writes/min), credential access blocked below trust 0.7
149
- 6. **Audit logging** — full record regardless of outcome
150
- 7. **Decision** — ALLOW, QUARANTINE, or BLOCK
151
-
152
- On recall, memories are filtered by trust score and sensitivity level. RESTRICTED content is redacted.
153
-
154
- ### Sub-Agent Security
155
-
156
- AI agents spawn sub-agents that inherit full system access. ShieldCortex isolates them:
157
-
158
- - **Agent hierarchy trust** — `user-spawned>task-1>subtask` scores decay 0.7× per level (max depth 5)
159
- - **Read ACLs** — trust ≥0.7: all memories; 0.5–0.7: own + shared; <0.5: own only
160
- - **Write restrictions** — untrusted agents auto-quarantined, parent approves
161
- - **Rate limiting** — 20 writes/min per source, hard block on exceed
162
- - **Credential isolation** — RESTRICTED memories blocked below trust 0.7
163
- - **Quarantine auto-expiry** — unreviewed items auto-rejected after 7 days
164
- - **Environment-based inference** — auto-detects Claude Code agents from env vars (not forgeable via MCP)
165
- - **Uninstall protection** — blocks agents from removing ShieldCortex
93
+ If your agent stores memories, ShieldCortex can power and protect them.
166
94
 
167
95
  ---
168
96
 
169
- ## MCP Tools
170
-
171
- | Tool | Description |
172
- |------|-------------|
173
- | `remember` | Store a memory (optional — hooks do this automatically) |
174
- | `recall` | Search memories by query, category, or tags |
175
- | `forget` | Delete memories |
176
- | `get_context` | Get relevant project context |
177
- | `memory_stats` | View memory statistics |
178
- | `scan_memories` | Scan existing memories for threats |
179
- | `audit_query` | Query the defence audit trail |
180
- | `quarantine_review` | Review quarantined memories |
181
- | `defence_stats` | Threat counts, trust distribution |
182
- | `graph_query` | Traverse the knowledge graph |
183
- | `graph_entities` | List known entities |
184
- | `graph_explain` | Find paths between entities |
185
-
186
- ---
97
+ ## Is Your AI Agent Already Compromised?
187
98
 
188
- ## Dashboard
99
+ Find out in 30 seconds:
189
100
 
190
101
  ```bash
191
- npx shieldcortex --dashboard
102
+ npx shieldcortex setup
192
103
  ```
193
104
 
194
- - **Dashboard**: http://localhost:3030
195
- - **API**: http://localhost:3001
105
+ Then ask your agent: **"Scan my memories for threats"**
196
106
 
197
- Views: Shield (defence overview), Audit Log, Quarantine, Memories, 3D Brain, Knowledge Graph.
198
-
199
- ### Auto-start on login
200
-
201
- ```bash
202
- npx shieldcortex service install # Enable
203
- npx shieldcortex service uninstall # Disable
204
- npx shieldcortex service status # Check
205
- ```
107
+ ShieldCortex will scan every stored memory and report:
108
+ - Hidden instructions disguised as normal content
109
+ - Credential harvesting attempts
110
+ - Encoded payloads (base64, unicode, hex)
111
+ - Fragmented attack patterns spread across memories
112
+ - Privilege escalation attempts
206
113
 
207
- Works on macOS (launchd), Linux (systemd), and Windows.
114
+ **No threats found?** Great — now you're protected going forward.
208
115
 
209
116
  ---
210
117
 
211
- ## CLI Reference
118
+ ## How It Works
212
119
 
213
- ```bash
214
- npx shieldcortex setup # Auto-detect agent + configure hooks
215
- npx shieldcortex migrate # Migrate from Claude Cortex
216
- npx shieldcortex doctor # Check installation health
217
- npx shieldcortex --dashboard # Start dashboard + API
218
- npx shieldcortex --version # Show version
219
- npx shieldcortex service install # Auto-start on login
220
- npx shieldcortex graph backfill # Extract entities from existing memories
221
- npx shieldcortex clawdbot install # Install OpenClaw hook
222
- npx shieldcortex uninstall # Full uninstall (requires confirmation)
223
- npx shieldcortex uninstall --confirm # Non-interactive uninstall
120
+ ```
121
+ ┌──────────┐ ┌──────────────────────────────────┐ ┌─────────────┐
122
+ │ │ │ ShieldCortex │ │ │
123
+ │ Agent │────▶│ Scan → Score → Store → Index │────▶│ SQLite DB │
124
+ │ │ │ Filter → Audit → Protect │ │ │
125
+ └──────────┘ └──────────────────────────────────┘ └─────────────┘
126
+ │ │
127
+ │ ┌─────────────────────┴─────────────────────┐
128
+ │ │ On Every Write: │
129
+ │ │ ✓ Scan for injection patterns │
130
+ │ │ ✓ Detect credential exposure │
131
+ │ │ ✓ Check encoding tricks │
132
+ │ │ ✓ Score trust level │
133
+ │ │ ✓ Log to audit trail │
134
+ │ └───────────────────────────────────────────┘
135
+ │
136
+ │ ┌─────────────────────────────────────────────┐
137
+ └───▶│ On Every Read: │
138
+ │ ✓ Filter by trust threshold │
139
+ │ ✓ Semantic search & ranking │
140
+ │ ✓ Redact sensitive content │
141
+ │ ✓ Log access to audit trail │
142
+ └─────────────────────────────────────────────┘
224
143
  ```
225
144
 
226
145
  ---
227
146
 
228
- ## Pricing
229
-
230
- | | Free (npm) | Pro (coming soon) |
231
- |---|---|---|
232
- | Memory Firewall | Yes | Yes |
233
- | Audit Logger | Yes | Yes |
234
- | Trust Scorer | Yes | Yes |
235
- | Retroactive Scanner | Yes | Yes |
236
- | Sensitivity Classifier | — | Yes |
237
- | Fragmentation Detector | — | Yes |
238
- | Cloud API | — | Yes |
239
- | Dashboard & Alerts | — | Yes |
240
- | Compliance Exports | — | Yes |
241
-
242
- Free tier is fully functional for individual developers. Pro adds enterprise defence layers and a hosted cloud API.
243
-
244
- ---
245
-
246
- ## Advanced Configuration
247
-
248
- <details>
249
- <summary>Alternative install methods</summary>
250
-
251
- ### Use with npx (no global install)
252
-
253
- Create `.mcp.json` in your project directory:
147
+ ## Configuration
254
148
 
255
149
  ```json
256
150
  {
257
- "mcpServers": {
258
- "memory": {
259
- "type": "stdio",
260
- "command": "npx",
261
- "args": ["-y", "shieldcortex"]
262
- }
151
+ "memory": {
152
+ "database": "~/.shieldcortex/memory.db",
153
+ "maxMemories": 10000,
154
+ "defaultImportance": "normal",
155
+ "decayEnabled": true,
156
+ "decayHalfLifeDays": 30
157
+ },
158
+ "security": {
159
+ "enableFirewall": true,
160
+ "enableAudit": true,
161
+ "trustThreshold": 0.5,
162
+ "quarantineOnThreat": true
163
+ },
164
+ "search": {
165
+ "semanticEnabled": true,
166
+ "maxResults": 20
263
167
  }
264
168
  }
265
169
  ```
266
170
 
267
- ### Install from source
268
-
269
- ```bash
270
- git clone https://github.com/Drakon-Systems-Ltd/ShieldCortex.git
271
- cd ShieldCortex
272
- npm install
273
- npm run build
274
- ```
275
-
276
- </details>
277
-
278
- <details>
279
- <summary>Custom database location</summary>
171
+ ---
280
172
 
281
- Default: `~/.shieldcortex/memories.db`
173
+ ## CLI Commands
282
174
 
283
175
  ```bash
284
- npx shieldcortex --db /path/to/custom.db
285
- ```
176
+ # Setup & Migration
177
+ shieldcortex setup # Auto-configure for your agent
178
+ shieldcortex migrate # Migrate from Claude Cortex
286
179
 
287
- </details>
180
+ # Memory Operations
181
+ shieldcortex remember "fact" # Store a memory
182
+ shieldcortex recall "query" # Search memories
183
+ shieldcortex forget <id> # Delete a memory
184
+ shieldcortex list # List recent memories
288
185
 
289
- <details>
290
- <summary>Environment variables</summary>
186
+ # Security Operations
187
+ shieldcortex scan # Scan all memories for threats
188
+ shieldcortex audit # View audit log
189
+ shieldcortex quarantine list # View quarantined memories
190
+ shieldcortex trust <id> <score> # Manually set trust score
291
191
 
292
- | Variable | Default | Description |
293
- |----------|---------|-------------|
294
- | `PORT` | `3001` | API server port |
295
- | `CORTEX_CORS_ORIGINS` | `localhost:3030,localhost:3000` | Allowed CORS origins |
296
-
297
- </details>
192
+ # Dashboard
193
+ shieldcortex dashboard # Open web dashboard (Pro)
194
+ ```
298
195
 
299
196
  ---
300
197
 
301
- ## LangChain Integration
198
+ ## Why ShieldCortex?
302
199
 
303
- ```javascript
304
- import { ShieldCortexMemory, ShieldCortexGuard } from 'shieldcortex/integrations/langchain';
200
+ | Feature | Claude Cortex | Mem0 | Zep | **ShieldCortex** |
201
+ |---------|---------------|------|-----|------------------|
202
+ | Persistent Memory | ✅ | ✅ | ✅ | ✅ |
203
+ | Semantic Search | ✅ | ✅ | ✅ | ✅ |
204
+ | Prompt Injection Detection | ❌ | ❌ | ❌ | ✅ |
205
+ | Memory Firewall | ❌ | ❌ | ❌ | ✅ |
206
+ | Sub-Agent Access Control | ❌ | ❌ | ❌ | ✅ |
207
+ | Audit Trail | ❌ | ❌ | ⚠️ | ✅ |
208
+ | Credential Protection | ❌ | ❌ | ❌ | ✅ |
209
+ | MCP Native | ✅ | ❌ | ❌ | ✅ |
210
+ | Self-Hosted | ✅ | ❌ | ⚠️ | ✅ |
211
+ | Open Source | ✅ | ⚠️ | ⚠️ | ✅ |
305
212
 
306
- // As a LangChain memory backend (scans before storing)
307
- const memory = new ShieldCortexMemory({ mode: 'balanced' });
308
- const vars = await memory.loadMemoryVariables({ input: 'deployment config' });
309
- await memory.saveContext({ input: 'hello' }, { output: 'hi' });
310
-
311
- // As standalone middleware (scan without storing)
312
- const guard = new ShieldCortexGuard();
313
- const result = guard.scan('some content to check');
314
- if (!result.allowed) {
315
- console.warn('Blocked:', result.firewall.reason);
316
- }
317
- ```
213
+ **ShieldCortex is the only memory system built for adversarial conditions.**
318
214
 
319
- ## REST API (Any Agent)
320
-
321
- Start the API server, then scan content from any language or framework:
322
-
323
- ```bash
324
- npm run dev:api # Starts on http://localhost:3001
325
- ```
326
-
327
- ```bash
328
- # Scan content
329
- curl -X POST http://localhost:3001/api/v1/scan \
330
- -H 'Content-Type: application/json' \
331
- -d '{"content": "memory to scan", "title": "test"}'
332
-
333
- # Batch scan
334
- curl -X POST http://localhost:3001/api/v1/scan/batch \
335
- -H 'Content-Type: application/json' \
336
- -d '{"items": [{"content": "item 1"}, {"content": "item 2"}]}'
337
-
338
- # Query audit logs
339
- curl http://localhost:3001/api/v1/audit?firewallResult=BLOCK
215
+ ---
340
216
 
341
- # List quarantined items
342
- curl http://localhost:3001/api/v1/quarantine
217
+ ## Pricing
343
218
 
344
- # Approve/reject quarantined items
345
- curl -X POST http://localhost:3001/api/v1/quarantine/1/approve
346
- curl -X POST http://localhost:3001/api/v1/quarantine/1/reject
347
- ```
219
+ | Tier | What You Get | Price |
220
+ |------|--------------|-------|
221
+ | **Free** | Full memory system + core security (firewall, audit, trust scoring) | £0 |
222
+ | **Pro** | + Sensitivity classifier, fragmentation detector, web dashboard | £29/mo |
223
+ | **Team** | + Multi-agent coordination, shared memory pools, team audit | £99/mo |
224
+ | **Enterprise** | + SSO, SLA, dedicated support, custom integrations | Contact us |
348
225
 
349
- All defence layers run automatically — firewall, trust scoring, sensitivity classification, and audit logging.
226
+ [Get Started Free](https://shieldcortex.ai) • [View Pricing](https://shieldcortex.ai/pricing)
350
227
 
351
228
  ---
352
229
 
353
- ## OpenClaw / Clawdbot Integration
354
-
355
- ```bash
356
- npx shieldcortex clawdbot install
357
- ```
230
+ ## Links
358
231
 
359
- The **cortex-memory** hook provides auto-save on `/new`, context injection on bootstrap, and keyword triggers ("remember this").
232
+ - 🌐 **Website:** [shieldcortex.ai](https://shieldcortex.ai)
233
+ - 📦 **npm:** [npmjs.com/package/shieldcortex](https://www.npmjs.com/package/shieldcortex)
234
+ - 🐙 **GitHub:** [github.com/Drakon-Systems-Ltd/ShieldCortex](https://github.com/Drakon-Systems-Ltd/ShieldCortex)
235
+ - 📖 **Docs:** [docs.shieldcortex.ai](https://docs.shieldcortex.ai)
236
+ - 🏢 **By:** [Drakon Systems](https://drakonsystems.com)
360
237
 
361
238
  ---
362
239
 
363
- ## Architecture
364
-
365
- See [ARCHITECTURE.md](ARCHITECTURE.md) for the full technical design — memory model, defence pipeline internals, database schema, and file structure.
240
+ ## Contributing
366
241
 
367
- ---
242
+ We welcome contributions! See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
368
243
 
369
244
  ## License
370
245
 
371
- MIT
246
+ MIT © [Drakon Systems Ltd](https://drakonsystems.com)
247
+
248
+ ---
372
249
 
373
- **Built by [Drakon Systems](https://github.com/Drakon-Systems-Ltd)**
250
+ <p align="center">
251
+ <strong>Give your AI agent a brain that fights back.</strong><br>
252
+ <a href="https://shieldcortex.ai">shieldcortex.ai</a>
253
+ </p>
package/dist/index.js CHANGED
File without changes
package/package.json CHANGED
@@ -1,7 +1,7 @@
1
1
  {
2
2
  "name": "shieldcortex",
3
- "version": "2.4.0",
4
- "description": "Security layer for AI agent memory — firewall, trust scoring, sensitivity classification, and audit for any memory backend",
3
+ "version": "2.4.1",
4
+ "description": "Complete memory system + security layer for AI agents. Persistent storage, semantic search, prompt injection firewall, credential protection, and audit trail. One package, full solution.",
5
5
  "main": "dist/index.js",
6
6
  "types": "dist/index.d.ts",
7
7
  "exports": {
@@ -40,16 +40,24 @@
40
40
  "prepublishOnly": "npm run build"
41
41
  },
42
42
  "keywords": [
43
+ "ai",
44
+ "agent",
45
+ "memory",
46
+ "persistent-memory",
47
+ "semantic-search",
43
48
  "security",
44
49
  "firewall",
45
- "ai-agent",
46
- "memory-protection",
47
- "threat-detection",
50
+ "prompt-injection",
48
51
  "mcp",
49
- "langchain",
50
52
  "claude",
51
- "prompt-injection",
52
- "audit"
53
+ "langchain",
54
+ "llm",
55
+ "ai-security",
56
+ "agent-memory",
57
+ "ai-memory",
58
+ "credential-protection",
59
+ "audit-trail",
60
+ "trust-scoring"
53
61
  ],
54
62
  "author": "Michael Kyriacou",
55
63
  "license": "MIT",