Labsco
Patdolitse logo

piia-engram

β˜… 168

from Patdolitse

Persistent AI memory across tools β€” remember your preferences, code standards, and decisions across Claude Code, Cursor, Codex, and any MCP tool. Local-first, zero-cloud.

πŸ”₯πŸ”₯πŸ”₯βœ“ VerifiedFreeQuick setup
#email#automation#database#cloud#devops#git#maps#finance

Piia Engram

Local-first AI work identity you can see, edit, and override β€” portable across your MCP coding tools.

Tell AI once who you are, how you work, and what "good" means. Claude Code, Codex, Cursor, Windsurf, and other MCP-compatible tools can start from the same AI work identity layer β€” local files you own, no cloud account, no hidden memory you cannot inspect.

Install Β· See It in Action Β· Supported Tools Β· MCP Tools Β· FAQ

ENGLISH | δΈ­ζ–‡

Listed in:

Also listed in: awesome-agents Β· Awesome-MCP-ZH Β· mcpservers.org Β· Cursor Directory Β· ModelScope Β· PulseMCP

TL;DR: piia-engram is a local-first personal AI identity layer. It helps multiple coding agents start from the same understanding of you: your preferences, quality bar, lessons learned, decisions, and project context. It is not an agent memory database; it is the user-owned layer above your tools.

Why not just use native memory? Claude Code, Codex, Cursor, and Windsurf are adding their own memories and rules. Those are useful, but they are scoped to one tool or workspace. piia-engram gives you one portable identity layer above them: local files you own, AI-proposed knowledge you review, and context that can follow you across tools.

Trust model in four lines:

  • No cloud account: install with pip, keep the core store on your machine.

  • Local files: identity and knowledge live under ~/.engram/ as JSON/Markdown.

  • User approval: AI writes locally; high-risk items (credentials, shell commands, MCP config, permission rules) wait for your review, while low/medium writes are auto-absorbed but fully auditable and reversible. Set ENGRAM_APPROVAL=strict to gate every write.

  • Documented boundaries: see Trust model, Privacy, and Security.

Want proof? See the live cross-tool continuity proof β€” a memory written by Claude Code, read back by Codex through one local store β€” or the one-command reproducible code demo.

See It in Action

Copy & paste β€” that's it
You β†’ "Help me refactor this auth module"

# WITHOUT piia-engram: AI starts from scratch
AI β†’ "What language? What framework? What's your testing preference?"

# WITH piia-engram: AI can load your approved context
AI β†’ "Based on your preference for pytest + 90% coverage, and your
 lesson about always separating auth middleware from business
 logic (from the March incident), here's my approach..."

And you never have to take that on faith β€” Memory Lens (engram preview --html) shows exactly what any AI caller would receive, and what governance withheld, before anything is sent:

Above: a real report from a demo store β€” 4 items exposed; an unreviewed staging note and a lesson containing a credential are withheld, with the secret shown as [REDACTED].

Supported Tools

Evidence levels follow the agent client validation runbook: L0 = untested, L1 = installed, L2 = read/search observed, L3 = static file bridge, L4 = cross-client continuity.

Tool Integration Evidence status Claude Code MCP over stdio L4 partial continuity proof (Claude Code -> Codex) Codex MCP over stdio L4 partial continuity proof (Claude Code -> Codex) Cursor MCP over stdio L2 setup/read-search evidence path Claude Desktop MCP over stdio L1/L2 setup path; client-specific evidence pending Hermes MCP over stdio L2 end-to-end verified (hermes-agent 0.15.2, 2026-06-03) OpenClaw SOUL.md / MEMORY.md / USER.md import and export L3 static file-bridge evidence ChatGPT / Gemini / Kimi Markdown identity card fallback Usable Windsurf MCP over stdio Expected to work GitHub Copilot MCP over stdio Expected to work Cline MCP over stdio Expected to work Roo Code MCP over stdio Expected to work Amazon Q MCP over stdio Expected to work Augment MCP over stdio Expected to work Zed MCP over stdio Expected to work Trae MCP over stdio Expected to work Tencent CodeBuddy MCP over stdio Expected to work

By the numbers

These are current repository facts from docs/public-facts.json. Public registries and package badges update only during release/publish.

Current repo / development facts Version frame v4.12.0 (verified 2026-06-23; check PyPI and GitHub Releases for the latest published package) Supported AI tools 16 (evidence level varies by client; see Supported Tools and the validation runbook) MCP tools 17 Core (loaded by default) + 40 Advanced (opt-in via ENGRAM_TOOLS=all) Knowledge types 3 (lessons, decisions, playbooks) Test suite Unit + integration; run pytest tests/ to verify Lines in core.py 1770 (facade; domain logic now lives in focused mixins β€” see architecture.md) PBKDF2 iterations 600,000 (OWASP 2023+ floor; legacy 100k still decrypts) Encryption Optional field-level AES-256-GCM for supported profile fields; local files are plaintext JSON/Markdown by default Cold-start time < 100 ms typical (local JSON, no network) Network calls by default 0 for identity and knowledge tools β€” except optional read_web_content; remote telemetry and feedback require separate explicit opt-in and send counts only (see privacy details)

Your AI forgets you every time you switch tools or start a new chat. piia-engram fixes the handoff.

Every time you open a new chat window, switch from Claude Code to Codex, update your AI tool, or move into a different project, you're back to zero:

  • your communication preferences β€” gone

  • your code standards and quality bar β€” forgotten

  • which mistakes you've already learned from β€” lost

  • why you made that architecture decision last month β€” erased

This happens because AI memory today is locked inside each platform. It belongs to the tool, not to you. The tool updates, resets, or gets replaced β€” and your context disappears with it.

piia-engram gives you a personal identity layer that lives on your machine, independent of any AI tool. You tell it once who you are, how you work, and what you've learned. MCP-compatible tools can read the same approved context. New chat, new tool, new version β€” your identity stays portable.

piia-engram is not an agent memory database. Tools like Mem0, Zep, and Letta store task context and session history for AI agents. piia-engram stores who you are as a person β€” your identity, preferences, hard-won lessons, and key decisions. It's a different layer: not what happened in a task, but who is behind every task.

Why piia-engram?

Without piia-engram With piia-engram New chat window = start from zero Configured conversations can load your approved context AI tool updates and your preferences vanish Your identity lives on your machine, survives any update Switching tools loses accumulated context Claude Code, Codex, and Cursor read the same memory Past mistakes get repeated Lessons learned follow you across tools and sessions Memory is locked inside one product Data stays local, editable, and portable

Who Uses piia-engram

piia-engram is built for developers who use multiple AI coding tools and are tired of re-explaining themselves.

If you switch between Claude Code, Codex, and Cursor β€” your code standards, architecture decisions, and hard-won lessons reset every time. piia-engram makes every tool start from the same understanding of who you are.

If you open 10+ AI chat windows a week β€” each one starts from zero. piia-engram lets each conversation start from the same approved identity and knowledge context.

If you've lost preferences after a tool update β€” your identity lives on your machine, not inside any platform. Updates, resets, and migrations don't touch your memory.

Other use cases Investment analysts Decisions get made but reasoning gets lost. piia-engram stores the full reasoning chain so six months later, "why did I pass on that?" has a real answer β€” and your analytical framework travels with you across every new analysis.

System architects Architecture decisions need context: what you chose, what you ruled out, and why. piia-engram keeps living Architecture Decision Records that travel with you across companies and projects, queryable by any AI tool.

Backend developers API quirks, integration gotchas, performance trade-offs β€” tacit knowledge that normally lives in your head and resets when you change jobs. piia-engram turns it into a searchable library that persists across everything.

Frontend and design Design philosophy rarely gets documented in a way AI tools can use. piia-engram stores your real standards, UX lessons from real users, and the reasoning behind component decisions β€” so every project starts where your last one ended.

Vibe coders You build with AI and move fast. The problem: every new session your AI starts from scratch β€” different style choices, inconsistent patterns, re-explaining the same preferences. piia-engram makes every tool consistent from session one: your stack, your patterns, your voice, already there.

What piia-engram Stores

All data lives under ~/.engram/ as plain JSON and Markdown files you can open, edit, back up, or migrate yourself.

  • Identity: who you are, how you communicate, what languages you prefer

  • Quality standards: your code review bar, test coverage expectations, what you refuse to ship

  • Preferences: coding style, AI behavior, how you like explanations

  • Trust boundaries: which fields to keep private, what tools can access

  • Project snapshots: context for ongoing work, captured and reloadable

  • Lessons learned: mistakes, surprises, things that worked and didn't

  • Key decisions: what you chose, what you ruled out, and why

  • Domain knowledge: reusable insights across projects and tools

What piia-engram Does (Beyond Storage)

Most memory tools are passive β€” you put things in, they give them back. piia-engram is also active.

Knowledge inheritance across projects Describe a new project in plain text. get_knowledge_inheritance returns a curated starter pack of the most relevant lessons and decisions from everything you have ever worked on. Your tenth project benefits from all nine before it β€” one tool call away.

Passive knowledge capture Paste a session summary into extract_session_insights and piia-engram extracts and stores the lessons and decisions. No manual note-taking. Knowledge accumulates through normal AI conversations.

Works with tools that do not support MCP ChatGPT, Gemini, Kimi β€” get_identity_card exports a ready-to-paste Markdown identity card. Your context travels even to tools that cannot connect directly.

Automatic playbook extraction Finish a multi-step workflow β€” release to PyPI, deploy to Cloudflare, publish to MCP Registry β€” and piia-engram detects it at session end. It generates a structured draft playbook (steps, pitfalls, trigger keywords) and saves it to a staging area. Next time you do the same task, the AI can retrieve the confirmed playbook as a passive reference, walk through the steps with you, and record the outcome. No manual recording required β€” Engram starts the draft, you confirm, the host AI stays accountable. See Playbook Auto-Extraction below.

Local tools registry AI tools constantly search for local programs, runtimes, and CLIs. register_tool records what's installed and where; find_tool retrieves it instantly. No more which python every session β€” the environment map persists across tools and conversations.

Knowledge health and discovery get_knowledge_overview surfaces stale lessons (not reviewed in 30+ days), computes a 0–100 health score across four dimensions (freshness, quality, coverage, cleanliness), and flags gaps worth revisiting. explore_knowledge scans your knowledge base for near-duplicates (and walks related/similar items) with actionable merge commands. manage_relation connects related lessons and decisions into a navigable knowledge graph.

Hybrid search (optional, off by default) The default keyword search stays unchanged. Opt in to hybrid retrieval β€” FTS5 full-text plus a semantic vector layer β€” for cross-lingual recall, e.g. an English query finding a Chinese note: pip install "piia-engram[vector]" and set ENGRAM_SEARCH=hybrid, or let engram setup enable it with one keystroke. The index is a rebuildable SQLite file; your JSON store remains the single source of truth. See docs/hybrid-search.md.

Upgrading

Copy & paste β€” that's it
pip install --upgrade piia-engram

After upgrading, piia-engram automatically migrates any stale MCP configs the next time its server starts (stdio mode). If your AI tool still shows an "MCP disconnected" error after restarting, run:

Copy & paste β€” that's it
piia-engram doctor # show what's wrong
piia-engram doctor --fix # auto-repair and fix in one step

Then restart the affected AI tool. The doctor command checks Claude Code, Cursor, Codex, Windsurf, Claude Desktop, and community-supported MCP config locations, removes outdated server entries, and prints a metadata-only config integrity summary.

MCP Tools

piia-engram ships 57 MCP tools. By default, only the 17 Tier-1 Core tools are loaded to keep the AI's context clean. Core means "used in most sessions", not "read-only": some core tools write local memory or owner-gated export files, and the governance layer still gates those side effects. For the short operator view, see the MCP cheatsheet. To unlock all 57 tools, add ENGRAM_TOOLS=all to your MCP config:

You can also expose composable capability modes such as knowledge management, governance, admin, or integrations; see the capability modes guide.

Copy & paste β€” that's it
{
 "mcpServers": {
 "piia-engram": {
 "command": "python",
 "args": ["-m", "piia_engram.mcp_server"],
 "env": { "ENGRAM_TOOLS": "all" }
 }
 }
}

Startup sync: Engram reconciles memories/config snippets from local AI tools when an MCP server starts. By default this runs in the background so stdio clients can initialize quickly. Set ENGRAM_MCP_STARTUP_SYNC=eager to restore synchronous startup sync, or ENGRAM_MCP_STARTUP_SYNC=off to skip startup sync for latency-sensitive test arms. ENGRAM_EPHEMERAL=1 also skips startup sync and migration work in container/ephemeral clients.

Tier-1 Core (17 tools β€” daily workflow)

Tool Purpose get_user_context Startup β€” Load identity + knowledge at session start (supports token_budget for context size control) wrap_up_session Session end β€” Save insights + sync at session end memory_store Writeback β€” Unified write endpoint: routes to add_lesson / add_decision / add_playbook by kind add_lesson Store a reusable lesson learned add_decision Record a key decision with reasoning add_playbook Record an operational playbook (multi-step procedure with trigger keywords) search_knowledge Retrieval β€” Search lessons, decisions, and playbooks (supports filters_json for domain/tier/date filtering) get_relevant_knowledge Find knowledge relevant to current project get_recall Return one structured identity + recent activity + relevant knowledge recall payload get_identity_card Owner-gated export: write and return a Markdown identity card for non-MCP tools update_identity Update profile, preferences, or quality standards get_project_context Read a saved project snapshot save_project_snapshot Persist project state for future sessions get_recent_context Recover lost session context after restart get_daily_log Read a human-friendly project timeline for a day get_resume_brief Build a cross-session/cross-tool resume brief doctor Run memory system self-diagnosis

Tier-2 Advanced (40 tools β€” knowledge management, review, governance, import/export)

Advanced tools include optional local integrations, owner/admin surfaces, and maintenance helpers. Tools that export files, import whole stores, generate review pages, or mutate caller trust are owner/admin/export surfaces even when they are broadly useful product capabilities. Related operations are consolidated into single tools with a mode/action selector (v4.0).

Click to expand full tool list

Tool Purpose register_tool Optional local integration governed write: register a local tool, runtime, or CLI to the environment map find_tool Optional local integration: look up a registered local tool by name list_tools Optional local integration: list registered local tools (optionally filter by category) save_agent_context Save AI session checkpoint (also runs automatically) list_agent_sessions Browse saved session records across tools refresh_quick_context Refresh local quick_context.md snapshot for offline/cross-tool use get_identity_facets Read identity facets via facet: profile, preferences, trust_boundaries, work_style, quality_standards, domains, or all user_portrait action: get / save / compare the AI-maintained user portrait preview_context_governance Advanced owner-gated preview: build safe-context, freshness/conflict, replay, or evidence proposals without applying changes get_playbooks Playbook reads via mode: list, get (full content), recent, management (incl. archived/deleted metadata) manage_playbook Playbook lifecycle via action: update, archive, delete, restore (mutations stay confirm-gated) playbook_execution Guided execution via action: prepare a step plan, update_step, status rollup (passive reference; no auto-execution) get_lessons List reusable lessons learned get_decisions List key decisions; thread_seed_id / history_question reconstruct decision threads and revision history get_knowledge_inheritance Build cross-project knowledge starter pack list_projects List saved project snapshots extract_session_insights Extract lessons and decisions from session text ingest_notes Parse free-form notes into structured knowledge update_knowledge Update a lesson or decision by ID archive_knowledge Archive a lesson or decision by ID confirm_knowledge Owner-only confirmation stamp via human, test, or anchor provenance onboard_repo Owner-only repo scan: create staging repo-fact candidates from anchors onboard_accept Owner-only accept: validate a candidate anchor and promote it to verified check_anchors Owner-only revalidation for existing anchor-backed facts merge_knowledge Merge a duplicate into the primary item manage_relation action: link / unlink β€” manage typed relations between knowledge items (decision threads) explore_knowledge Knowledge graph exploration via mode: related, similar, merge_candidates get_knowledge_overview Knowledge digest, health report, stale checks get_stale_knowledge List items that need review review_staging Staging review hub via action: list pending, batch decisions, review_item, apply_text review results export_knowledge_report Owner-gated export: write a readable Markdown knowledge report request_outline_review Owner-gated export: generate an interactive local HTML review page export_engram Owner-gated export: write a full backup (format="openclaw" for OpenClaw-compatible files) import_engram Owner/admin import: use dry_run=True first for a metadata-only merge/conflict preview (format="openclaw" supported) read_web_content Fetch a user-provided URL: prefers a local sidecar if running, otherwise uses the self-contained built-in reader (pip install "piia-engram[reader]") get_audit_log Get recent audit log entries start_project Start a project with inherited knowledge get_permission_profile View all callers' trust levels and access boundaries manage_caller_trust Owner/admin action: grant / revoke a caller's trust level export_feedback_report Internal/dogfood: generate an anonymous beta feedback report

Legacy Playbook scope migration (classify / apply / rollback / review queue) moved out of the MCP surface into the owner-only local CLI: engram playbook scope classify|apply|rollback|queue|resolve (previews by default; writes require --apply --yes).

Playbook Auto-Extraction

piia-engram can detect multi-step workflows you complete during a session and automatically draft structured playbooks β€” no manual recording required.

How It Works

  • Detection β€” When you call wrap_up_session or save_agent_context, piia-engram scans for procedural workflow signals: checkpoint steps, action verbs, and trigger keywords.

  • Draft generation β€” If a workflow is detected, a playbook draft is created with steps, pitfalls, trigger keywords, and preconditions. Sensitive information (API keys, tokens, absolute paths) is automatically redacted before storage.

  • Staging β€” The draft is saved to a staging area, never auto-promoted to verified. You review and confirm before it becomes a trusted playbook.

  • Schema contract β€” Stored playbooks are normalized into a versioned contract: trigger keywords, preconditions, pitfalls, structured steps, and optional required_tools declarations. Thin drafts remain reviewable, but carry machine-readable quality warnings.

  • Tool resolution β€” Playbooks declare tool needs by name or purpose, while local paths stay in the tools registry. playbook_execution (action prepare) returns resolved_tools, tools_ready, and missing_tools at runtime so the host AI can see which local tools are available without storing resolved paths in the Playbook.

  • Reuse and outcome β€” Next time an AI tool encounters a similar task, search_knowledge matches the trigger keywords and returns the playbook as a passive reference. The host AI walks through the steps with you and playbook_execution (action status) reports an outcome rollup (pending, partial, succeeded, or failed) instead of treating skipped steps as silent success.

Design Philosophy: Engram Starts, You Confirm, AI Applies

Playbook auto-extraction is not fully automatic. piia-engram detects the workflow and generates a rough draft β€” but the draft stays in staging until you explicitly confirm it. Once confirmed, AI tools can use the playbook as a governed, passive reference and record step outcomes; Engram does not silently execute the workflow for them. This keeps humans in the loop for quality control while eliminating the manual work of writing operational procedures.

Confidence Levels

Level Signal AI Behavior high 3+ checkpoint steps from save_agent_context AI notifies you: "Detected a reusable workflow, draft playbook generated." medium Text-based detection (trigger keywords + action verbs) AI saves silently to staging, no notification.

Sensitive Info Redaction

Before any draft is stored, piia-engram automatically redacts:

  • API keys and tokens (Bearer, sk-, ghp_, etc.)

  • Absolute file paths (Windows and Unix)

  • Email addresses

  • Environment variable secrets

Kill Switch

Users can disable or re-enable playbook auto-extraction at any time:

  • Disable: Tell your AI "ε…³ι—­ playbook" / "stop playbook" / "disable playbook auto-extraction"

  • Enable: Tell your AI "开启 playbook" / "start playbook" / "enable playbook auto-extraction"

The AI calls update_identity(field="preferences", ...) to toggle playbook_auto_extract. Default is enabled.

Manual Playbook Creation

You can always create playbooks manually with add_playbook, regardless of the auto-extraction setting. The kill switch only affects automatic detection during wrap_up_session.

Data Layout

Copy & paste β€” that's it
~/.engram/
|-- schema_version.json
|-- identity/
| |-- profile.json
| |-- preferences.json
| |-- quality_standards.json
| `-- trust_boundaries.json
|-- knowledge/
| |-- lessons.json
| |-- decisions.json
| `-- domains.json
|-- playbooks/
| |-- _index.json
| `-- {playbook_id}.json
|-- tools/
| `-- registry.json
|-- projects/
| `-- {project_id}.json
|-- contexts/
| `-- {tool_name}/
| `-- {session_id}.md
|-- exports/
`-- compat/
 `-- openclaw/

Own & export your data

Everything lives in local JSON you own β€” inspect, edit, back up, or delete it directly. Three explicit export paths, each with a different boundary:

Want Tool What it includes A portable card to paste into ChatGPT/Gemini/Kimi get_identity_card Curated Markdown: who you are, how you work, recent verified lessons/decisions. Excludes raw config-file knowledge and caps recent items. A readable knowledge report export_knowledge_report Active lessons/decisions grouped by domain/month (Markdown). A full local backup export_engram / import_engram(dry_run=True) / engram import <backup.json> The whole store as JSON. Treat the file as sensitive β€” it is a complete backup, including staging and labelled items. Preview imports first to see add/skip/conflict counts without writing data. OpenClaw files export_engram (format="openclaw") SOUL.md / MEMORY.md / USER.md. A committable AGENTS.md/CLAUDE.md digest engram export-agents-md Verified, non-sensitive lessons/decisions only, as a summary block. Staging and sensitive items are excluded by construction; refuses to overwrite an existing file.

Exports are owner-gated when ENGRAM_GOVERNANCE=1 (see docs/governance.md). There is no cloud copy and no hidden memory: what you export is exactly what is on your disk.

Local data sovereignty. Backup and restore cover only the Engram directory β€” engram backup-plan prints a metadata-only list of what to copy before an upgrade (it reads no stored knowledge bodies and never reaches outside the Engram root). For JSON backups, import_engram(..., dry_run=True) or engram import <backup.json> returns a metadata-only merge plan with add/skip/conflict counts before any write; --apply --yes is required to mutate the local store. Same-summary lessons and same-question decisions with divergent semantic fields are previewed as version-chain candidates; they are materialized only when the owner explicitly runs engram import <backup.json> --apply --yes --materialize-version-chain. Engram never backs up, modifies, or deletes files in your project folders. See docs/runbooks/setup-upgrade-safety.md.

Comparison

Feature piia-engram Claude Memory Manual CLAUDE.md Mem0 Letta (MemGPT) Primary purpose User identity across tools Per-conversation memory Per-project notes Agent vector memory Agent self-editing memory Cross-tool by design βœ… MCP-native (17 core tools) ❌ Claude only ❌ tool-specific ⚠ requires per-tool wiring ⚠ requires per-tool wiring Storage Local JSON in ~/.engram/ Cloud Local Vector DB + Mem0 Cloud Postgres or Letta Cloud Local-first by default βœ… ❌ βœ… ⚠ Cloud is the default ⚠ Cloud is the default Encryption at rest βœ… AES-256-GCM, PBKDF2 600k (opt-in) depends on Cloud ❌ plain Markdown depends on store config depends on Postgres config Knowledge tiers βœ… high-risk staged; strict-mode gates all ❌ ❌ ❌ ❌ Conflict detection βœ… ❌ ❌ ❌ ❌ MCP-native βœ… n/a n/a ⚠ third-party ⚠ third-party Price Free, AGPL-3.0 Subscription-bundled Free Free / Cloud tiers Free / Cloud tiers

πŸ“Š For the full side-by-side, including when to choose a competitor over piia-engram, see docs/comparison.md.

Built With

piia-engram is a human-directed, AI-assisted open-source project.

Contributor Role @Patdolitse Creator, product direction, strategy, ownership Claude Code Architecture, task planning, code review assistance Codex Implementation, testing, documentation assistance

CLI Commands

Copy & paste β€” that's it
engram setup # Interactive install wizard (confirms before writing client configs)
engram setup --apply-external-config # Skip the confirm prompt (non-interactive/CI); writes with backups
piia-engram doctor # Check config health + governance state
piia-engram status # Redacted install + memory/governance summary
piia-engram status --html # Write a local redacted status page
piia-engram preview # Show what a simulated AI caller would receive (--as ROLE, --level, --html)
piia-engram continuity # Prove cross-tool handoff readiness (metadata only)
piia-engram management # Show a metadata-only review/playbook management view
piia-engram doctor --fix # Auto-repair any issues found
piia-engram sessions # List saved cross-tool agent sessions
piia-engram sessions show # Print one saved session
piia-engram review # List staging knowledge awaiting review
piia-engram review show # Inspect one review item
piia-engram review approve --yes # Promote a staging item
piia-engram review archive --yes # Archive a review item
piia-engram management action review approve --yes --json # Structured metadata-only action receipt
piia-engram management action playbook delete --yes --json # Soft-delete a Playbook without body echo
piia-engram management action playbook_scope accept_project --project . --yes --json # Resolve ambiguous Playbook scope
piia-engram management action playbook_scope accept_shared --project ./app-a --project ./app-b --yes --json # Share one Playbook with selected projects
piia-engram dock-status # Zero-write Dock owner-console status (--json)
piia-engram repair-encoding # Dry-run scan for garbled / mojibake text
piia-engram repair-encoding --apply # Repair reversible cases with a backup
piia-engram backup-plan # Metadata-only plan of what to copy before upgrading (local-only)
piia-engram export-agents-md # Export verified, non-sensitive knowledge as an AGENTS.md/CLAUDE.md block
piia-engram stats # Show project growth metrics (GitHub + PyPI)
piia-engram stats --log # Append stats snapshot to local log
engram telemetry # Manage anonymous usage statistics
engram privacy # Show what data piia-engram stores and where

Contributing

Contributions, issues, and feedback are welcome.

See CONTRIBUTING.md.

License

AGPL-3.0. piia-engram is free software. Your AI work identity and memory belong to you.