The system behind the studio.

You are my implementation architect for a portable AI memory and context system.

I want to build my own version of the MOTION Core pattern: a durable memory index, a canonical source-of-truth library, repeatable agent bootstrap instructions, cross-machine configuration sync, and a secure credential retrieval protocol.

Your job is to design and implement this for my environment, not merely explain it.

First, interview my current setup:
- Operating systems and machines I use
- AI clients I use: Claude, Codex, Cursor, ChatGPT, Perplexity, or others
- Whether each client supports MCP over Streamable HTTP (/mcp), SSE (/sse), or stdio
- My source-of-truth tools: Notion, Obsidian, Google Drive, OneDrive, GitHub, local files, or others
- My preferred deployment platform: Railway, Fly.io, Render, Supabase, Neon, AWS, GCP, Azure, or local-only
- My credential store: GCP Secret Manager, 1Password, Doppler, AWS Secrets Manager, Keychain, env files, or another vault
- My dotfile/config sync tool: chezmoi, stow, Mackup, private Git repo, MDM, or manual setup

Then produce an implementation plan with these layers:

1. Memory index
- Pick or confirm a memory server such as Stash (or an equivalent MCP memory service). Prefer Streamable HTTP at /mcp; keep SSE only for legacy clients.
- Back it with Postgres plus vector search when possible.
- Define the primary behaviors: recall for semantic retrieval, remember for durable conclusions, and optional helpful/harmful/neutral feedback that adjusts retrieval utility only.
- Store distilled facts, decisions, preferences, and pointers. Do not store raw chat transcripts.

2. Source-of-truth library
- Choose the canonical document system.
- Create an AI Router document that stores exact page IDs, database IDs, repo paths, and runbook locations.
- Make memory facts point to the full documents instead of duplicating them.
- Define the rule: memory is the index; the document system is the database.

3. Cheapest-first context lookup
- Define a lookup order that starts with the cheapest and fastest layer.
- Use this default order unless my tools require changes:
  1. Memory recall
  2. AI Router or index page
  3. One exact source-of-truth document
  4. Repo-local instructions such as AGENTS.md, CLAUDE.md, README.md, or docs
  5. Heavy storage or broad search only as a last resort
- Include a rule to stop once the answer is found.

4. Namespace taxonomy
- Propose namespaces for durable memory.
- Include at minimum:
  /self
  /self/preferences
  /self/capabilities
  /self/limits
  /tools
  /projects/<project-name>
  /clients/<client-name>
  /people/<person-name>
- Define what belongs in each namespace and what should never be stored.

5. Agent bootstrap protocol
- Write starter AGENTS.md and CLAUDE.md instructions.
- Include rules for session start, recall before advice, source-of-truth lookup, credential probing, and remembering durable decisions.
- Make the protocol portable across Claude, Codex, Cursor, and other coding agents.

6. MCP wiring
- Generate config examples for every AI client I use.
- Prefer Streamable HTTP /mcp URL examples with bearer auth.
- Include SSE /sse examples only where a client still requires them.
- Include a local stdio bridge only when a client cannot take a remote URL.

7. Cross-machine sync
- Define how each machine gets the same agent config, MCP config, shell tools, skills, and bootstrap files.
- Prefer a private dotfiles repo managed by chezmoi if appropriate.
- Separate config sync from memory sync: dotfiles sync the environment; the hosted database syncs memory.

8. Credential hygiene
- Design a credential probe protocol.
- Use this order unless my environment requires changes:
  1. Local environment files and existing CLI auth
  2. Central secret manager
  3. Per-tool credential stores
  4. OS keychain
  5. Ask me only after all probes fail
- Never paste secrets into prompts, memory, docs, or code.
- Include setup for least-privilege service accounts where relevant.

9. Security and exposure
- Treat the memory endpoint as sensitive infrastructure.
- Explain how to protect any hosted memory server with authentication, network controls, or a private tunnel.
- Warn me before exposing a remote MCP endpoint to third-party clients.

10. Deliverables
Create the actual files I need, including:
- A repo structure
- AGENTS.md
- CLAUDE.md
- MCP config templates
- A memory namespace taxonomy
- An AI Router template
- A credential probe runbook
- A cross-machine setup checklist
- A security checklist
- Any setup scripts needed for local bridges or client reconnects

Work in phases. First give me the architecture choices and tradeoffs. Then ask for only the missing facts you truly need. After that, generate the implementation files and commands.