memory-unlocked 1.0.0__tar.gz

memory_unlocked-1.0.0/CHANGELOG.md

@@ -0,0 +1,69 @@
+# Changelog
+
+## 1.0.0 - Stable Local MCP for Students
+
+### Added
+
+- Stable local-per-installation contract: every new store starts with zero memories and has no connection to any maintainer or other student store.
+- `memory-unlocked doctor` for version, backend, writability, scope, and aggregate-count diagnostics without exposing memory bodies.
+- Student quickstart covering isolated SQLite setup, MCP binding, backup, restore, and deletion.
+- Release-artifact smoke that verifies an empty initial store, nine MCP tools, same-scope recall, and cross-project isolation.
+- MCP protocol negotiation through the official `2025-11-25` version while retaining support for `2024-11-05`, `2025-03-26`, and `2025-06-18` clients.
+- Fail-closed JSON-RPC validation for malformed messages, invalid params, and notifications that must never receive responses.
+- Linux Python 3.9-3.13, macOS Python 3.11, and Windows Python 3.11 CI coverage.
+- Verified wheel/sdist publication workflow with checksums, GitHub release assets, and PyPI trusted publishing.
+- Split, least-privilege release jobs with SHA-pinned GitHub Actions and a PyPI job that receives only verified wheel/sdist artifacts.
+
+### Security
+
+- The public package ships no database, memory export, environment file, private namespace, or hosted-service connection.
+- Tenant/project remain process-bound MCP configuration and are never model-controlled tool arguments.
+
+## 0.3.1 - Semantic Graph Layer
+
+### Added
+
+- Deterministic public-safe semantic graph extraction.
+- Relation vocabulary: `owns`, `routes_to`, `separate_from`, `uses_provider`, `fallback_provider`, `deploys_to`, `source_of_truth_for`, `sensitive_write`, `depends_on`, `supersedes`.
+- Spanish/Spanglish extraction patterns including `usa`, `depende de`, `fuente de verdad`, `no mezclar`, `fallback a`.
+- Nearest-subject fallback binding for `fallback_provider`.
+- CLI commands: `graph` and `graph-context`.
+- MCP tool: `memory_graph_context`.
+- Graph docs and public example.
+
+### Security
+
+- Graph reports/context omit memory bodies.
+- Entity/relation names pass secret/PII filters before emission.
+- Graph extraction remains namespace-scoped and deterministic.
+
+## 0.3.0 - Productization Preview
+
+Memory Unlocked moves from an installable skeleton to a product-grade local agent memory toolkit.
+
+### Added
+
+- SQLite backend via `--backend sqlite` / `MEMORY_UNLOCKED_BACKEND=sqlite`.
+- Lifecycle states: `candidate`, `active`, `archived`, `rejected`.
+- Governance commands: `audit`, `review`, `status`, `forget`.
+- Token-budgeted context assembly via CLI `context --token-budget` and MCP `memory_context`.
+- Offline eval harness: `memory-unlocked eval examples/evalset/basic.json`.
+- Safer context rendering that treats memories as data, not instructions.
+- Size limits and PII handling policy knobs.
+- Public examples for Hermes, team memory, SQLite production, and evalsets.
+
+### Security
+
+- Recall logs redact secret-shaped queries.
+- Rejected writes never persist the rejected content.
+- Memory bodies are omitted from governance reports.
+
+## 0.2.0
+
+- CLI and MCP server.
+- Durable JSONL storage.
+- Secret policy gate and public docs.
+
+## 0.1.0
+
+- Public architecture skeleton, schema, examples, and tests.

memory_unlocked-1.0.0/CODE_OF_CONDUCT.md

@@ -0,0 +1,7 @@
+# Code of Conduct
+
+Be respectful, practical, and security-minded.
+
+This project exists to help people build safer AI-agent memory. Contributions that harass people, expose private data, add backdoors, or intentionally weaken privacy/security are not welcome.
+
+If you see a problem, use the repository's GitHub moderation/reporting tools or contact the maintainers through GitHub.

memory_unlocked-1.0.0/CONTRIBUTING.md

@@ -0,0 +1,28 @@
+# Contributing
+
+Thanks for improving Memory Unlocked.
+
+## Local setup
+
+```bash
+python -m venv .venv
+. .venv/bin/activate
+python -m pip install -e '.[dev]'
+python -m pytest -q
+```
+
+## Rules
+
+1. Never commit `.env`, credentials, tokens, private customer data, internal domains, or realistic-looking secrets.
+2. Add tests for policy, namespace isolation, persistence, and CLI/MCP behavior when touching those areas.
+3. Keep core dependencies minimal; stdlib is preferred.
+4. Public docs must use placeholders like `acme`, `billing`, `MEMORY_UNLOCKED_HOME`, and `[REDACTED]`.
+5. Do not add telemetry or network calls to the core package without a clear opt-in.
+
+## Pull request checklist
+
+- [ ] `python -m pytest -q` passes
+- [ ] `python -m compileall -q memory_unlocked` passes
+- [ ] examples still use fake/public data only
+- [ ] no generated caches or build artifacts committed
+- [ ] changelog updated for user-visible changes

memory_unlocked-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Memory Unlocked contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

memory_unlocked-1.0.0/MANIFEST.in

@@ -0,0 +1,10 @@
+include CHANGELOG.md
+include CODE_OF_CONDUCT.md
+include CONTRIBUTING.md
+include LICENSE
+include README.md
+include ROADMAP.md
+include SECURITY.md
+recursive-include docs *.md
+recursive-include examples *.md *.json
+recursive-include scripts *.py

memory_unlocked-1.0.0/PKG-INFO

@@ -0,0 +1,247 @@
+Metadata-Version: 2.4
+Name: memory-unlocked
+Version: 1.0.0
+Summary: A privacy-first, scope-isolated local memory store for AI agents, with a CLI and an MCP server.
+Author: Memory Unlocked contributors
+License-Expression: MIT
+Project-URL: Documentation, https://github.com/josenaicipa/memory-unlocked/tree/main/docs
+Project-URL: Source, https://github.com/josenaicipa/memory-unlocked
+Keywords: ai,agents,memory,privacy,namespace,mcp
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: ruff<1,>=0.14; extra == "dev"
+Dynamic: license-file
+
+# Memory Unlocked
+
+A **privacy-first, scoped local memory** for AI agents. Memory Unlocked gives
+agents durable, project-scoped memory without leaking secrets or letting one
+project's context bleed into another.
+
+It is installable today as a dependency-free Python package with:
+
+- durable local JSONL and SQLite stores,
+- a practical CLI (`memory-unlocked`),
+- a dependency-free MCP stdio server (`memory-unlocked-mcp`),
+- lifecycle/governance commands for candidate review, archival, and forgetting,
+- token-budgeted context assembly and offline recall/privacy evals,
+- a deterministic semantic graph layer for typed agent context,
+- audit events for writes, recalls, updates, forgets, and rejections,
+- tests and CI for the privacy/scope guarantees.
+
+The core stays deliberately small so teams can audit it, ship it locally, and
+adapt it to their own database, vector index, or hosted service later.
+
+**v1 local-isolation contract:** every installation starts with an empty local
+store. It does not include sample memories, connect to a maintainer database, or
+share data with any other installation. Each user owns their own JSONL/SQLite
+files. See the [student quickstart](docs/student-quickstart.md).
+
+---
+
+## Why this exists
+
+Long-running agents need to remember things between sessions — decisions,
+conventions, gotchas, references. But naive "just dump everything into a vector
+store" memory has two failure modes:
+
+1. **Secret leakage** — credentials, tokens, customer data, and PII end up
+   persisted and later surfaced in unrelated contexts.
+2. **Scope bleed** — memory from Project A contaminates answers about Project B.
+
+Memory Unlocked treats both as first-class concerns. Every memory is scoped to a
+namespace, every write passes a redaction/policy gate, and recall is filtered by
+scope before anything reaches the model.
+
+---
+
+## Who it is for
+
+- Builders of multi-project agent systems who need **isolated** memory per scope.
+- Teams that want **auditable, reviewable** writes instead of a black-box store.
+- Anyone who wants a **readable reference architecture** they can port to their
+  own database, vector index, or MCP server.
+
+---
+
+## Quickstart
+
+```bash
+pipx install memory-unlocked
+# or: uv tool install memory-unlocked
+```
+
+From source:
+
+```bash
+git clone https://github.com/josenaicipa/memory-unlocked.git
+cd memory-unlocked
+python -m pip install -e '.[dev]'
+python -m pytest -q
+```
+
+Write and recall a memory from the CLI:
+
+```bash
+memory-unlocked --path ./mem init
+memory-unlocked --path ./mem write \
+  --tenant acme --project billing \
+  --title "Refunds run through the async queue" \
+  --body "Refund requests are enqueued and processed by a worker, not inline." \
+  --source docs/refunds.md \
+  --tags billing,architecture
+memory-unlocked --path ./mem context \
+  --tenant acme --project billing --query refund --token-budget 200
+```
+
+Review candidate memories and run governance/eval checks:
+
+```bash
+memory-unlocked --path ./mem write \
+  --tenant acme --project billing \
+  --title "Candidate fact" --body "Needs human approval." \
+  --source docs/review.md --status candidate
+memory-unlocked --path ./mem review --tenant acme --project billing
+memory-unlocked --path ./mem audit --json
+memory-unlocked eval examples/evalset/basic.json
+```
+
+Use SQLite for a more production-like local backend:
+
+```bash
+memory-unlocked --backend sqlite --path ./mem-sqlite init
+memory-unlocked --backend sqlite --path ./mem-sqlite doctor
+```
+
+Extract semantic graph context and the public-safe graph reports:
+
+```bash
+memory-unlocked --path ./mem write \
+  --tenant acme --project billing \
+  --title "Graph demo" \
+  --body "Billing service owns refunds. Worker depends on Redis." \
+  --source docs/graph.md
+memory-unlocked --path ./mem graph-context \
+  --tenant acme --project billing --token-budget 200
+memory-unlocked --path ./mem graph-temporal \
+  --tenant acme --project billing --json
+memory-unlocked --path ./mem graph-lineage \
+  --tenant acme --project billing --json
+memory-unlocked --path ./mem graph-effective-backend \
+  --tenant acme --project billing --json
+```
+
+The extra graph reports are read-only and public-safe: `graph-lineage` emits
+opaque handles instead of raw memory ids/source refs, `graph-temporal` derives
+relation validity from source-memory timestamps, and `graph-effective-backend`
+returns the scoped graph as the canonical `memory_unlocked` backend payload for
+agent/MCP consumers.
+
+
+Run the MCP server for an agent runner:
+
+```bash
+MEMORY_UNLOCKED_TENANT=acme \
+MEMORY_UNLOCKED_PROJECT=billing \
+MEMORY_UNLOCKED_HOME="$HOME/.memory_unlocked" \
+  memory-unlocked-mcp
+```
+
+Use the core package directly:
+
+```python
+from memory_unlocked import (
+    Memory, Source, Namespace, MemoryStore, ContextAssembler, PolicyError,
+)
+
+store = MemoryStore()
+
+store.add(Memory(
+    namespace=Namespace("acme", "billing"),
+    title="Refunds run through the async queue",
+    body="Refund requests are enqueued and processed by a worker, not inline.",
+    source=Source(kind="doc", ref="docs/refunds.md"),
+    tags=["billing", "architecture"],
+))
+
+# Recall is scope-filtered: only memories in the requested namespace come back.
+assembler = ContextAssembler(store)
+context = assembler.assemble(Namespace("acme", "billing"), query="refund")
+print(context)
+```
+
+Writes that contain obvious secrets, or that lack a verifiable source, are
+rejected at the gate:
+
+```python
+store.add(Memory(
+    namespace=Namespace("acme", "billing"),
+    title="API key",
+    body="AWS_SECRET_ACCESS_KEY=AKIA...",   # raises PolicyError
+    source=Source(kind="doc", ref="notes.md"),
+))
+```
+
+---
+
+## Core concepts
+
+| Concept | What it is |
+| --- | --- |
+| **Memory** | One atomic fact, with a title, body, tags, and a required source. |
+| **Source** | Provenance for a memory (a file, URL, ticket, or run id). No source → no write. |
+| **Namespace** | A `tenant / project` scope. Recall never crosses namespaces. |
+| **Policy / redaction** | A gate every write passes before it is stored. |
+| **Context assembler** | Builds a scope-filtered, ranked context block for the agent. |
+| **Event** | An append-only record of writes and recalls for auditability. |
+
+---
+
+## Privacy-first guardrails
+
+These are the defaults, not opt-ins:
+
+- **Never store secrets.** Writes are scanned for credential-shaped content and
+  rejected. See [`docs/privacy-and-redaction.md`](docs/privacy-and-redaction.md).
+- **Every memory needs a source.** Unattributed claims are rejected so memory
+  stays verifiable.
+- **Scope isolation by default.** A recall in `tenant/project` cannot return a
+  memory written under any other scope.
+- **No raw transcripts, no PII, no customer/lead data.** Store durable, stable
+  facts — not transient progress or personal information.
+- **Writes are reviewable.** Every write and recall emits an event so you can
+  audit what the memory fabric learned and surfaced.
+
+---
+
+## Documentation
+
+- [Install & CLI](docs/install.md) — package install, JSONL/SQLite stores, CLI commands.
+- [Student quickstart](docs/student-quickstart.md) — isolated local setup starting with zero memories.
+- [Hermes / MCP](docs/hermes.md) — run the MCP server and bind it to a project scope.
+- [Semantic graph](docs/graph.md) — typed relation extraction and graph context.
+- [Threat model](docs/threat-model.md) — public security boundaries and residual risk.
+- [Release checklist](docs/release-checklist.md) — repeatable PyPI/release process.
+- [Architecture](docs/architecture.md) — components, data flow, scope policy.
+- [Privacy & redaction](docs/privacy-and-redaction.md) — what never to store and
+  the write-review flow.
+- [Schema](docs/schema.md) — the canonical memory, source, link, and event shapes.
+- [Integrations](docs/integrations.md) — MCP / HTTP / CLI patterns for agent runners.
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).

memory_unlocked-1.0.0/README.md

@@ -0,0 +1,221 @@
+# Memory Unlocked
+
+A **privacy-first, scoped local memory** for AI agents. Memory Unlocked gives
+agents durable, project-scoped memory without leaking secrets or letting one
+project's context bleed into another.
+
+It is installable today as a dependency-free Python package with:
+
+- durable local JSONL and SQLite stores,
+- a practical CLI (`memory-unlocked`),
+- a dependency-free MCP stdio server (`memory-unlocked-mcp`),
+- lifecycle/governance commands for candidate review, archival, and forgetting,
+- token-budgeted context assembly and offline recall/privacy evals,
+- a deterministic semantic graph layer for typed agent context,
+- audit events for writes, recalls, updates, forgets, and rejections,
+- tests and CI for the privacy/scope guarantees.
+
+The core stays deliberately small so teams can audit it, ship it locally, and
+adapt it to their own database, vector index, or hosted service later.
+
+**v1 local-isolation contract:** every installation starts with an empty local
+store. It does not include sample memories, connect to a maintainer database, or
+share data with any other installation. Each user owns their own JSONL/SQLite
+files. See the [student quickstart](docs/student-quickstart.md).
+
+---
+
+## Why this exists
+
+Long-running agents need to remember things between sessions — decisions,
+conventions, gotchas, references. But naive "just dump everything into a vector
+store" memory has two failure modes:
+
+1. **Secret leakage** — credentials, tokens, customer data, and PII end up
+   persisted and later surfaced in unrelated contexts.
+2. **Scope bleed** — memory from Project A contaminates answers about Project B.
+
+Memory Unlocked treats both as first-class concerns. Every memory is scoped to a
+namespace, every write passes a redaction/policy gate, and recall is filtered by
+scope before anything reaches the model.
+
+---
+
+## Who it is for
+
+- Builders of multi-project agent systems who need **isolated** memory per scope.
+- Teams that want **auditable, reviewable** writes instead of a black-box store.
+- Anyone who wants a **readable reference architecture** they can port to their
+  own database, vector index, or MCP server.
+
+---
+
+## Quickstart
+
+```bash
+pipx install memory-unlocked
+# or: uv tool install memory-unlocked
+```
+
+From source:
+
+```bash
+git clone https://github.com/josenaicipa/memory-unlocked.git
+cd memory-unlocked
+python -m pip install -e '.[dev]'
+python -m pytest -q
+```
+
+Write and recall a memory from the CLI:
+
+```bash
+memory-unlocked --path ./mem init
+memory-unlocked --path ./mem write \
+  --tenant acme --project billing \
+  --title "Refunds run through the async queue" \
+  --body "Refund requests are enqueued and processed by a worker, not inline." \
+  --source docs/refunds.md \
+  --tags billing,architecture
+memory-unlocked --path ./mem context \
+  --tenant acme --project billing --query refund --token-budget 200
+```
+
+Review candidate memories and run governance/eval checks:
+
+```bash
+memory-unlocked --path ./mem write \
+  --tenant acme --project billing \
+  --title "Candidate fact" --body "Needs human approval." \
+  --source docs/review.md --status candidate
+memory-unlocked --path ./mem review --tenant acme --project billing
+memory-unlocked --path ./mem audit --json
+memory-unlocked eval examples/evalset/basic.json
+```
+
+Use SQLite for a more production-like local backend:
+
+```bash
+memory-unlocked --backend sqlite --path ./mem-sqlite init
+memory-unlocked --backend sqlite --path ./mem-sqlite doctor
+```
+
+Extract semantic graph context and the public-safe graph reports:
+
+```bash
+memory-unlocked --path ./mem write \
+  --tenant acme --project billing \
+  --title "Graph demo" \
+  --body "Billing service owns refunds. Worker depends on Redis." \
+  --source docs/graph.md
+memory-unlocked --path ./mem graph-context \
+  --tenant acme --project billing --token-budget 200
+memory-unlocked --path ./mem graph-temporal \
+  --tenant acme --project billing --json
+memory-unlocked --path ./mem graph-lineage \
+  --tenant acme --project billing --json
+memory-unlocked --path ./mem graph-effective-backend \
+  --tenant acme --project billing --json
+```
+
+The extra graph reports are read-only and public-safe: `graph-lineage` emits
+opaque handles instead of raw memory ids/source refs, `graph-temporal` derives
+relation validity from source-memory timestamps, and `graph-effective-backend`
+returns the scoped graph as the canonical `memory_unlocked` backend payload for
+agent/MCP consumers.
+
+
+Run the MCP server for an agent runner:
+
+```bash
+MEMORY_UNLOCKED_TENANT=acme \
+MEMORY_UNLOCKED_PROJECT=billing \
+MEMORY_UNLOCKED_HOME="$HOME/.memory_unlocked" \
+  memory-unlocked-mcp
+```
+
+Use the core package directly:
+
+```python
+from memory_unlocked import (
+    Memory, Source, Namespace, MemoryStore, ContextAssembler, PolicyError,
+)
+
+store = MemoryStore()
+
+store.add(Memory(
+    namespace=Namespace("acme", "billing"),
+    title="Refunds run through the async queue",
+    body="Refund requests are enqueued and processed by a worker, not inline.",
+    source=Source(kind="doc", ref="docs/refunds.md"),
+    tags=["billing", "architecture"],
+))
+
+# Recall is scope-filtered: only memories in the requested namespace come back.
+assembler = ContextAssembler(store)
+context = assembler.assemble(Namespace("acme", "billing"), query="refund")
+print(context)
+```
+
+Writes that contain obvious secrets, or that lack a verifiable source, are
+rejected at the gate:
+
+```python
+store.add(Memory(
+    namespace=Namespace("acme", "billing"),
+    title="API key",
+    body="AWS_SECRET_ACCESS_KEY=AKIA...",   # raises PolicyError
+    source=Source(kind="doc", ref="notes.md"),
+))
+```
+
+---
+
+## Core concepts
+
+| Concept | What it is |
+| --- | --- |
+| **Memory** | One atomic fact, with a title, body, tags, and a required source. |
+| **Source** | Provenance for a memory (a file, URL, ticket, or run id). No source → no write. |
+| **Namespace** | A `tenant / project` scope. Recall never crosses namespaces. |
+| **Policy / redaction** | A gate every write passes before it is stored. |
+| **Context assembler** | Builds a scope-filtered, ranked context block for the agent. |
+| **Event** | An append-only record of writes and recalls for auditability. |
+
+---
+
+## Privacy-first guardrails
+
+These are the defaults, not opt-ins:
+
+- **Never store secrets.** Writes are scanned for credential-shaped content and
+  rejected. See [`docs/privacy-and-redaction.md`](docs/privacy-and-redaction.md).
+- **Every memory needs a source.** Unattributed claims are rejected so memory
+  stays verifiable.
+- **Scope isolation by default.** A recall in `tenant/project` cannot return a
+  memory written under any other scope.
+- **No raw transcripts, no PII, no customer/lead data.** Store durable, stable
+  facts — not transient progress or personal information.
+- **Writes are reviewable.** Every write and recall emits an event so you can
+  audit what the memory fabric learned and surfaced.
+
+---
+
+## Documentation
+
+- [Install & CLI](docs/install.md) — package install, JSONL/SQLite stores, CLI commands.
+- [Student quickstart](docs/student-quickstart.md) — isolated local setup starting with zero memories.
+- [Hermes / MCP](docs/hermes.md) — run the MCP server and bind it to a project scope.
+- [Semantic graph](docs/graph.md) — typed relation extraction and graph context.
+- [Threat model](docs/threat-model.md) — public security boundaries and residual risk.
+- [Release checklist](docs/release-checklist.md) — repeatable PyPI/release process.
+- [Architecture](docs/architecture.md) — components, data flow, scope policy.
+- [Privacy & redaction](docs/privacy-and-redaction.md) — what never to store and
+  the write-review flow.
+- [Schema](docs/schema.md) — the canonical memory, source, link, and event shapes.
+- [Integrations](docs/integrations.md) — MCP / HTTP / CLI patterns for agent runners.
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).

memory_unlocked-1.0.0/ROADMAP.md

@@ -0,0 +1,41 @@
+# Roadmap
+
+Memory Unlocked is a safe, portable local memory layer for MCP-compatible AI agents.
+
+## v1.0 - Stable Local MCP
+
+- [x] Dependency-free CLI and MCP package
+- [x] JSONL and SQLite local backends
+- [x] Empty-by-default, local-per-installation student model
+- [x] Process-bound tenant/project isolation
+- [x] Lifecycle, review, audit, export, import, and forgetting
+- [x] Offline recall/privacy eval harness
+- [x] Deterministic public-safe semantic graph
+- [x] Current MCP protocol negotiation with backward compatibility
+- [x] Cross-platform CI and exact release-artifact smoke
+- [x] Student quickstart, threat model, and privacy documentation
+
+## v1.x - Optional Local Enhancements
+
+- [ ] encrypted-at-rest local option
+- [ ] signed export/import bundles
+- [ ] richer duplicate merge workflow
+- [ ] visual graph UI on top of the deterministic semantic graph
+- [ ] additional MCP-client setup recipes
+
+## Future Team/Hosted Layer
+
+These are separate products and are not implied by the local v1 contract:
+
+- [ ] Postgres backend with migrations
+- [ ] authenticated multi-user service
+- [ ] tenant authorization, RBAC, quotas, and deletion controls
+- [ ] hosted dashboard and organization governance reports
+
+## Non-goals
+
+- Storing raw conversations by default.
+- Becoming a generic vector database.
+- Depending on paid embedding APIs for the core package.
+- Connecting student installations to a maintainer/private database.
+- Shipping private deployment details in the public repository.

memory_unlocked-1.0.0/SECURITY.md

@@ -0,0 +1,23 @@
+# Security Policy
+
+Memory Unlocked is designed to reject secrets and isolate agent memory by namespace.
+
+## Reporting vulnerabilities
+
+Use GitHub private vulnerability reporting / security advisories for this repository. Do not open a public issue containing exploit details or sensitive data.
+
+## Supported versions
+
+The latest minor release receives security fixes.
+
+## Security design promises
+
+- Namespace is selected by the operator/runtime, not by the model.
+- Rejected writes do not store the rejected content.
+- Governance reports omit memory bodies.
+- Secret-shaped queries are redacted in audit events.
+- The core package does not call external services.
+
+## What not to submit
+
+Please do not send real API keys, credentials, customer records, private internal URLs, or private conversation transcripts in issues, PRs, examples, or tests.