Your project.
A fresh assistant.

01 / TWO DIFFERENT JOBS

Choose your path

The client runs beside your agent. It keeps a private durable outbox. The server keeps originals in SQLite and derived memory in Hindsight/PostgreSQL.

Self-hosted storage does not mean all processing is local. The model provider can receive approved retained content. Embeddings and reranking use local models in this configuration.

02 / BEFORE YOU CONNECT

Prepare your computer

• Use macOS or Linux with Python 3.11 or later and uv.
• Obtain an authorized Memvek source checkout. Repository access can be required. No published package is assumed.
• Install the native agent separately. The current validation targets are Claude Code 2.1.316, Codex 0.166.0 and OMP 18.15.0.
• On macOS, use an accessible login Keychain. A fresh session can require human unlock.
• On Linux, use an active user session with /usr/bin/systemd-creds and working user-encrypted credential support.
• Do not assume Windows support. This launcher supports macOS and Linux only.

Your native agent has separate authentication and model charges. A Memvek processing grant does not cover the agent's own provider usage.

Replace the example paths with your actual absolute paths. Keep the source checkout and virtual environment available while the integrations are installed.

export MEMVEK_SOURCE="/absolute/path/to/memvek"
cd "$MEMVEK_SOURCE"
uv sync --locked
export PATH="$MEMVEK_SOURCE/.venv/bin:$PATH"
memvek-integrate --help

export MEMVEK_PROJECT_ROOT="/absolute/path/to/garden"
cd "$MEMVEK_PROJECT_ROOT"

Use an existing project directory. The installer resolves its canonical path. Run native agents from that project, not from the Memvek checkout.

Do not copy generated agent configuration to another project. The launcher checks the actual caller project before credential access. Ordinary subdirectories remain valid unless they contain another project boundary.

Claude supplies its native CLAUDE_PROJECT_DIR identity. Other callers need a cwd within the bound project. An unproven caller context fails closed.

03 / SKIP THIS FOR AN EXISTING SERVICE

Host a server

Prepare an owned loopback Docker deployment

1. Install Docker with Compose support on the selected macOS or Linux server.
2. Select a new, owned Compose project name and unused loopback port.
3. Use a local Docker Unix socket, not an SSH/TCP context or a socket forwarded to another computer. Docker Desktop's local VM socket is suitable.
4. Arrange the gateway route and its independent authorization token.
5. Approve model startup probes and subsequent processing under a new, explicit spending grant.
6. Create four independent secret records in approved storage: client token, Hindsight token, database password and dummy gateway token.
7. Keep each value at least 32 characters. Use URL-safe letters, digits, underscores or hyphens for the database password.

The default processing model is gpt-6-luna, with reasoning effort none. Hindsight and PostgreSQL use pinned images. Local model caches must be available with Hugging Face offline mode enabled.

The provider can charge for startup probes, extraction and retries. The gateway must count all attempts. Restart is not a budget reset. Historical trial grants are not reusable.

Define the nonsecret inputs in the same shell. Supply the actual gateway URL from its operator, including its API base path. Clear Docker endpoint overrides, then record the selected context's endpoint. Do not use a forwarded Unix socket.

unset DOCKER_HOST DOCKER_CONTEXT
export MEMVEK_DOCKER_ENDPOINT="$(docker context inspect --format '{{.Endpoints.docker.Host}}')"
printf 'Docker endpoint: %s\n' "$MEMVEK_DOCKER_ENDPOINT"
case "$MEMVEK_DOCKER_ENDPOINT" in unix:///*) echo "Check this is a local, non-forwarded socket." ;; *) echo "Stop: a local Unix socket is required." ;; esac
cd "$MEMVEK_SOURCE"
export MEMVEK_COMPOSE_PROJECT="memvek-garden"
export MEMVEK_BIND_IP="127.0.0.1"
export MEMVEK_PORT="8787"
export MEMVEK_PROJECTS='{"garden":"garden-bank"}'
printf 'Approved gateway API base URL: '
read -r MEMVEK_MODEL_GATEWAY_URL
export MEMVEK_MODEL_GATEWAY_URL

garden is the client-visible project ID. garden-bank is its dedicated backend bank. Use unique banks. Preserve exact existing mappings for existing data.

Only after those prerequisites and permissions are complete, run this attended startup command. Secret input is hidden and sent to Docker through the child environment.

set +x
set +v
python3 - <<'PY'
import getpass, json, os, re, resource, stat, subprocess, warnings
warnings.simplefilter("error", getpass.GetPassWarning)
resource.setrlimit(resource.RLIMIT_CORE, (0, 0))
names = ("MEMVEK_COMPOSE_PROJECT", "MEMVEK_BIND_IP", "MEMVEK_PORT",
         "MEMVEK_PROJECTS", "MEMVEK_MODEL_GATEWAY_URL", "MEMVEK_DOCKER_ENDPOINT")
env = {key: os.environ[key] for key in
       ("HOME", "PATH", "LANG", "DOCKER_CONFIG", "XDG_RUNTIME_DIR") if key in os.environ}
env.update({key: os.environ[key] for key in names})
endpoint = env.pop("MEMVEK_DOCKER_ENDPOINT")
if not endpoint.startswith("unix:///") or not stat.S_ISSOCK(os.stat(endpoint[7:]).st_mode):
    raise SystemExit("Select a local Docker Unix socket, not a remote endpoint")
env["DOCKER_HOST"] = endpoint
if env["MEMVEK_BIND_IP"] != "127.0.0.1":
    raise SystemExit("This procedure permits host loopback only")
if not re.fullmatch(r"[a-z0-9][a-z0-9_-]*", env["MEMVEK_COMPOSE_PROJECT"]):
    raise SystemExit("Choose an owned Compose project name")
subprocess.run(["docker", "--host", endpoint, "ps", "--all", "--filter",
                "label=com.docker.compose.project=" + env["MEMVEK_COMPOSE_PROJECT"]], check=True)
try:
    with open("/dev/tty", "r") as terminal, open("/dev/tty", "w") as prompt:
        prompt.write("Type OWNED after checking this project is yours: ")
        prompt.flush()
        confirmed = terminal.readline().strip()
except OSError:
    raise SystemExit("A private interactive terminal is required") from None
if confirmed != "OWNED":
    raise SystemExit("Choose a project you own")
projects = json.loads(env["MEMVEK_PROJECTS"])
if not isinstance(projects, dict) or not projects or any(
    not re.fullmatch(r"[a-z0-9][a-z0-9_-]{0,127}", key)
    or not isinstance(bank, str) or not bank for key, bank in projects.items()
) or len(set(projects.values())) != len(projects):
    raise SystemExit("Use explicit project IDs with unique bank names")
secrets = ("MEMVEK_CLIENT_TOKEN", "MEMVEK_HINDSIGHT_TOKEN",
           "MEMVEK_DB_PASSWORD", "MEMVEK_MODEL_GATEWAY_TOKEN")
try:
    for key in secrets:
        value = getpass.getpass(key + " (not a provider key): ")
        if not 32 <= len(value) <= 512 or not value.isascii() or not value.isprintable() or any(c.isspace() for c in value):
            raise SystemExit("Use 32–512 printable ASCII characters without spaces")
        env[key] = value
except (EOFError, getpass.GetPassWarning):
    raise SystemExit("A private interactive terminal is required") from None
if len({env[key] for key in secrets}) != len(secrets):
    raise SystemExit("Use four independent secret values")
if not re.fullmatch(r"[A-Za-z0-9_-]+", env["MEMVEK_DB_PASSWORD"]):
    raise SystemExit("The database password must be URL-safe")
result = subprocess.run(
    ["docker", "compose", "--env-file", "/dev/null", "-p",
     env["MEMVEK_COMPOSE_PROJECT"], "up", "-d", "--build", "--wait"],
    env=env, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
if result.returncode:
    raise SystemExit("Compose startup failed. Containers may still run; follow the stop procedure below.")
print("Compose startup returned success; check local readiness separately")
PY

Only after startup reports success, check readiness:

curl --fail --silent --show-error "http://127.0.0.1:$MEMVEK_PORT/health/ready"

The readiness response includes status: ready and a correlation ID. It checks the application, local store and worker task. It does not prove indexing or retrieval quality.

Only Memvek's loopback port is published. Hindsight and PostgreSQL remain unpublished. Normal bridge networks permit egress; they are not gateway-only destination firewalls.

Connect another device only through private HTTPS

The loopback procedure does not permit remote clients. For another device, arrange a private reachable HTTPS address and valid certificate first.

The existing compose.tls.yaml overlay supports direct Uvicorn TLS. It needs absolute MEMVEK_TLS_CERT_FILE, MEMVEK_TLS_KEY_FILE and MEMVEK_TLS_CA_FILE paths.

The leaf certificate needs the selected private address and loopback address as SANs. Container UID 10001 must read its key without broad permissions. Never mount the CA signing key.

A remote deployment needs its own authorized TLS, ownership and gateway checks. Do not publish plain HTTP on the LAN. Do not use a wildcard host bind or disable certificate checks.

Rootless Podman has additional UID, user-service and gateway transport requirements. This Docker procedure does not claim generic Podman setup or turnkey reboot support.

04 / CLIENT TOKEN ONLY

Store the client token

Get the client token from your service operator through an approved private channel. It must match MEMVEK_CLIENT_TOKEN on that service.

The client must not receive the Hindsight credential, database password or provider key. Do not put token values in terminal arguments, project configuration or saved shell scripts.

macOS: login Keychain

1. Open Keychain Access.
2. Create a password item in your login Keychain.
3. Set its service/item name to org.example.memvek.client.
4. Set its account to memvek-client.
5. Enter the client token in the password field.
6. Save the item without granting unrelated applications access.

The installer takes the service and account names, not the password. The launcher uses /usr/bin/security find-generic-password. A locked store fails closed without an environment fallback.

Linux: user-encrypted systemd record

This route requires a working systemd-creds --user broker for your user. Availability depends on the installed systemd and machine policy.

The launcher uses /run/user/<uid> and its user bus. It does not create a service account, unlock a TPM or change groups. No unattended-unlock claim is made.

Select a private absolute record path outside your repositories. The following command reads the client token privately and saves encrypted bytes only.

export MEMVEK_CLIENT_CREDENTIAL="$HOME/.config/memvek/credentials/client-token.cred"
set +x
set +v
python3 - <<'PY'
import getpass, os, resource, stat, subprocess, warnings
from pathlib import Path
warnings.simplefilter("error", getpass.GetPassWarning)
resource.setrlimit(resource.RLIMIT_CORE, (0, 0))
path = Path(os.environ["MEMVEK_CLIENT_CREDENTIAL"])
if not path.is_absolute() or path.resolve() != path or path.exists() or path.is_symlink():
    raise SystemExit("Choose a new canonical absolute record path")
path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
owner = path.parent.stat()
if owner.st_uid != os.getuid() or stat.S_IMODE(owner.st_mode) & 0o077:
    raise SystemExit("The credential directory must be owner-private")
try:
    token = getpass.getpass("Memvek client token: ")
except (EOFError, getpass.GetPassWarning):
    raise SystemExit("A private interactive terminal is required") from None
if not 32 <= len(token) <= 512 or not token.isascii() or not token.isprintable() or any(c.isspace() for c in token):
    raise SystemExit("Invalid client-token format")
runtime = "/run/user/" + str(os.getuid())
env = {key: os.environ[key] for key in ("HOME", "PATH", "LANG") if key in os.environ}
env.update(XDG_RUNTIME_DIR=runtime, DBUS_SESSION_BUS_ADDRESS="unix:path=" + runtime + "/bus")
result = subprocess.run(
    ["/usr/bin/systemd-creds", "encrypt", "--user", "--name=client-token", "-", str(path)],
    input=token.encode(), env=env, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
if result.returncode:
    raise SystemExit("User-encrypted credential provisioning failed; stop and inspect broker support")
path.chmod(0o600)
print("Encrypted client record created; native retrieval still needs validation")
PY

Do not repeat a failed provisioning command over an existing output. Reconcile that record first. Do not fall back to a plaintext token file.

05 / ONE PROJECT, ONE EXPLICIT MAP

Connect your agent

Use the exact project ID from your operator. The following garden example needs the server map shown earlier.

For an existing remote service, supply its private HTTPS URL. Obtain the public CA file through a trusted channel. Do not copy a CA signing key.

cd "$MEMVEK_PROJECT_ROOT"
printf 'Private Memvek service URL: '
read -r MEMVEK_URL
printf 'Configured Memvek project ID: '
read -r MEMVEK_PROJECT_ID

Choose the command for your OS. Change --runtime to claude, codex or omp. Each command installs one adapter.

macOS adapter installation

memvek-integrate install --root "$MEMVEK_PROJECT_ROOT" --runtime claude \
  --url "$MEMVEK_URL" --project-id "$MEMVEK_PROJECT_ID" \
  --credential-kind keychain \
  --credential-service org.example.memvek.client \
  --credential-account memvek-client

Linux adapter installation

memvek-integrate install --root "$MEMVEK_PROJECT_ROOT" --runtime codex \
  --url "$MEMVEK_URL" --project-id "$MEMVEK_PROJECT_ID" \
  --credential-kind systemd \
  --credential-file "$MEMVEK_CLIENT_CREDENTIAL" \
  --credential-name client-token

For a private CA, append --ca-file "/absolute/path/to/public-ca.pem" to the install command. Without this argument, the client uses verified system trust.

Only literal loopback HTTP is accepted without TLS. Invalid explicit trust fails closed. The client does not follow redirects or use environment proxy/CA overrides.

For private-CA HTTPS, check readiness with that public CA. Replace the path before this command:

export MEMVEK_PUBLIC_CA="/absolute/path/to/public-ca.pem"
curl --cacert "$MEMVEK_PUBLIC_CA" --fail --silent --show-error \
  "${MEMVEK_URL%/}/health/ready"

For a system-trusted certificate or literal loopback HTTP, omit only the --cacert argument. Keep certificate verification enabled.

The installer does not contact the service or retrieve credentials. A successful install is configuration creation, not a successful connection.

memvek-integrate status --root "$MEMVEK_PROJECT_ROOT"

The JSON output reports the canonical root, state directory, binding, runtime flags, policy version and pending installation status.

The root hash uses the canonical project path. Moving the project creates another identity; the installer does not migrate old queues. Keep existing state.

The generated project settings contain machine-specific paths. Keep those changes out of shared commits; each person should install their own binding. The installer does not change your Git ignore rules.

Claude: register the generated plugin explicitly

Generated settings alone returned an empty native plugin list in an isolated check. The following registration then succeeded with network denied and no credentials.

STATE=$(memvek-integrate status --root "$MEMVEK_PROJECT_ROOT" \
  | python3 -c 'import json,sys; print(json.load(sys.stdin)["state"])')
MARKETPLACE=$(python3 -c \
  'import json,sys; print(json.load(open(sys.argv[1]))["name"])' \
  "$STATE/marketplace/.claude-plugin/marketplace.json")
PLUGIN_ID="memvek@$MARKETPLACE"
cd "$MEMVEK_PROJECT_ROOT"
claude plugin marketplace add "$STATE/marketplace" --scope project --json
claude plugin install "$PLUGIN_ID" --scope project --json
claude plugin list --json

Check that the list shows the qualified plugin, project scope, enabled state and expected MCP configuration. This does not prove skill loading or tool calls.

Accept the workspace trust and project MCP prompts only after you inspect this configuration. Do not add global permission bypasses.

Codex: use its native adapter

Run the OS install command with --runtime codex. In a trusted project, inspect its native MCP list:

cd "$MEMVEK_PROJECT_ROOT"
codex mcp list --json

A trusted temporary project discovered Memvek in the native list. Start a fresh Codex session to check the explicit skills and actual calls.

OMP: use its native adapter

Run the OS install command with --runtime omp. In a fresh OMP session, use /mcp list to inspect connected tools.

OMP can import Codex configuration and .agents skills, plus Claude plugins. The adapters use the same endpoint for deduplication. Check actual discovery before use.

Existing independent registrations or changed owned files cause refusal. Do not overwrite them or edit ownership receipts to force installation.

06 / AN EXPECTED WORKFLOW, NOT A TEST TRANSCRIPT

Try one approved note

Do this only after native discovery, credential access and the service connection work. Processing needs its own active budget approval.

These are explicit skill invocations. Nothing saves every chat, reads memory automatically at startup, or captures a session at exit. No automatic hooks are installed.

1. Save exactly one nonsecret note

   Invoke the capture skill. Say: “I approve saving this exact note for garden: Maple Garden workday is Saturday. Bring gloves.”

   Supply the real date, scope, authority and source when asked. Keep the returned record, request and operation IDs privately.

2. Read the outcome honestly

   pending is durable acceptance, not completed indexing. Ask for operation status using the saved ID. ready needs observed completion.

   A failed or uncertain result needs reconciliation. Do not allocate another request ID just to make the result look successful.

3. Start a fresh agent in the same project

   Invoke the resume skill. Ask: “Resume the garden workday plan and show the exact source for its date.”

   If several tasks match, choose one explicitly. Inspect relevant exact originals, including omitted context. An unavailable search is not a no-match result.

4. Approve a correction

   Invoke the correct skill. Say: “Replace that Saturday note with: Maple Garden workday is Sunday. Bring gloves. I approve this correction.”

   The agent must use the actual record and revision. Read the active Sunday replacement. The Saturday original is history, not current guidance.

5. Save and read a handoff

   Invoke the handoff skill. Approve task garden-workday, title “Garden workday”, and this content: “Sunday is current. Next, check the tool list.”

   If that task exists, use its actual revision. In another fresh session, invoke resume for garden-workday and read the handoff.

6. Forget only the old original

   Invoke the forget skill. Say: “Forget only the old Saturday original identified during correction. Keep the Sunday replacement and the handoff.”

   Check the target ID before approval. Local suppression is immediate; backend cleanup can remain pending or failed. Do not describe it as complete early.

Memory does not copy the tool-list file or authorize commands. Ask for missing files. Your current instructions and repository sources remain authoritative.

OPTIONAL / OWNER-RUN CHECK

Run the agent check

Use an isolated test project and test service. Do not use production memory for this check.

Model calls can cost money. Set an enforceable spending limit before you start. A CLI estimate is not a hard limit.

1. Prepare

   Connect the test service to an approved, bounded model gateway. Configure the test project on that service.

   Install each adapter in the test project. Use a test client credential. Start each agent in that project.

2. Check each agent

   For Claude, Codex and OMP, check that the Memvek tools and skills appear. Use the commands in the connection section.

   Save one different, nonsecret example note per agent. Approve each note before the agent saves it.

3. Check a fresh session

   Wait for each saved operation to complete. A pending operation is not a completed result.

   Start a fresh session of the same agent. Ask it to resume the note and show its original source.

   Ask the agent to correct the note. Check the corrected source. Then request a handoff or forget the test note explicitly.

4. Record the result

   For each agent, record its version, pass or fail, and the step that failed. Record the observed spending.

   Keep request IDs and operation IDs private. Do not share tokens, source text, transcripts or credential files.

If a result is pending, unavailable or uncertain, preserve its operation ID. Do not repeat a write with a new ID to force success.

07 / KEEP YOUR QUEUE AND ORIGINALS

Update, disable or remove

Update the authorized source checkout first. Then install its locked environment and refresh each installed adapter.

cd "$MEMVEK_SOURCE"
uv sync --locked
memvek-integrate update --root "$MEMVEK_PROJECT_ROOT" --runtime claude
memvek-integrate update --root "$MEMVEK_PROJECT_ROOT" --runtime codex
memvek-integrate update --root "$MEMVEK_PROJECT_ROOT" --runtime omp

Run only the lines for adapters you installed. Restart the native session after configuration or credential changes. Check discovery again.

Modified owned files cause refusal rather than forced replacement. Preserve those files and reconcile the conflict. An interrupted installation keeps a pending ownership intent.

Disable

memvek-integrate disable --root "$MEMVEK_PROJECT_ROOT" --runtime claude
memvek-integrate disable --root "$MEMVEK_PROJECT_ROOT" --runtime codex
memvek-integrate disable --root "$MEMVEK_PROJECT_ROOT" --runtime omp

Disable enabled Claude and Codex adapters before OMP. Otherwise OMP can import them, so the installer refuses its exclusion without changing configuration.

Use enable instead of disable to restore an installed adapter. Enable OMP first if it is disabled and you need imported adapters again.

Disable/remove does not need a working CA, endpoint or unlocked credential. It still requires safe local ownership and the exact project binding.

Remove Codex or OMP

memvek-integrate remove --root "$MEMVEK_PROJECT_ROOT" --runtime codex
memvek-integrate remove --root "$MEMVEK_PROJECT_ROOT" --runtime omp

Remove or disable remaining Claude imports before OMP removal. These commands remove owned adapter artifacts only. Unrelated settings, credentials, outbox and server memory remain.

Remove Claude

From the same project and Claude configuration directory used to install the plugin, first remove its native project registration. Use the PLUGIN_ID obtained during registration above. Do not run native and managed lifecycle commands at the same time.

claude plugin uninstall "$PLUGIN_ID" --scope project --keep-data --json
memvek-integrate remove --root "$MEMVEK_PROJECT_ROOT" --runtime claude

The managed command refuses removal while another Claude scope or marketplace still uses the source. Follow its reported next steps; do not force a cleanup. Claude's native registry and cache, credentials, outbox and server memories remain. Restart an existing Claude session to apply the change.

Claude's default configuration is ~/.claude. If you use CLAUDE_CONFIG_DIR, use the same directory for installation, Claude commands and managed lifecycle actions. Unknown native metadata or alternate cache overrides fail closed.

No command here forgets server memory. Forgetting is a separate, explicit record operation. Do not delete an outbox to repair an uncertain write.

08 / OBSERVE BEFORE RETRYING

Find the cause

The launcher reports project_binding_or_native_credential_unavailable without raw broker output. The installer reports integration_conflict_or_configuration_unavailable.

Share correlation IDs and content-free state, not original payloads, tokens, resolved Compose output or environment dumps. Replay and outbox retry require an explicit decision.

09 / SERVER OWNERSHIP CONTINUES

Keep data recoverable

Keep the SQLite originals and PostgreSQL backend together in a paired backup. Keep newer lifecycle/deletion records independently. An old backup must not revive forgotten advice.

The recovery tools require owned physical fencing and isolated destinations. They are administrative tools, not agent skills. A client export is not a full server backup.

No daily backup schedule is installed by this guide. Approve retention, encryption, off-host copies and a recovery exercise separately.

Normal server restarts preserve named volumes and queued identities. They can also repeat startup probes. Reuse the same stored credentials, project map and gateway ledger.

The base Compose services use restart policies. Reboot support still depends on Docker, the model gateway, its credential custody and its active grant.

A separate personal finite deployment is not a product-wide permanent grant. Expired budgets, unsupported reboot state or unavailable models must fail closed, not renew automatically.

Do not run down --volumes, erase a ledger, replace banks or discard an outbox as troubleshooting. Stopping containers is not proof of API-level forgetting.

For an ordinary base-Compose restart, repeat the attended startup procedure with the same owned project, map and secret records. Do not generate replacement identities.

Stop a partial or running deployment

A failed startup does not mean containers stopped. In the same shell, use the recorded local socket and project name. First inspect the matching containers; do not proceed if they belong to another deployment.

docker --host "$MEMVEK_DOCKER_ENDPOINT" ps --all \
  --filter "label=com.docker.compose.project=$MEMVEK_COMPOSE_PROJECT"
python3 - <<'PY'
import os, stat, subprocess
endpoint = os.environ["MEMVEK_DOCKER_ENDPOINT"]
project = os.environ["MEMVEK_COMPOSE_PROJECT"]
if not endpoint.startswith("unix:///") or not stat.S_ISSOCK(os.stat(endpoint[7:]).st_mode):
    raise SystemExit("Select the same local Docker Unix socket")
if not project:
    raise SystemExit("Select the owned Compose project")
docker = ["docker", "--host", endpoint]
result = subprocess.run(docker + ["ps", "--quiet", "--filter",
    "label=com.docker.compose.project=" + project], check=True, capture_output=True, text=True)
ids = result.stdout.split()
if ids:
    subprocess.run(docker + ["stop", *ids], check=True)
subprocess.run(docker + ["ps", "--all", "--filter",
    "label=com.docker.compose.project=" + project], check=True)
PY

This stops matching running containers; it does not remove containers or volumes. Verify their displayed status. Stop the separate gateway using its own operator procedure; this command does not stop it.

10 / EVIDENCE HAS A BOUNDARY

Know what was checked

• Native Codex in a trusted temporary project discovered Memvek through codex mcp list --json.
• Native Claude 2.1.316 project registration and installation produced an enabled project plugin with the expected MCP configuration. Managed removal refused before native uninstall and succeeded afterward.
• That Claude smoke used an isolated home, denied network and no credentials. It did not prove skill loading, memory calls or full live use.
• OMP 18.15.0 discovered the five Memvek skills in an isolated, network-blocked session; authenticated MCP use remains unverified.
• The static page was previewed at desktop and mobile widths; a clean-user end-to-end run remains unverified.

Final acceptance needs all three native agents, real supported credential retrieval, the approved server route, source inspection and the complete note workflow.

Provider-backed checks need their own purpose, trial count, spending cap and approval. Browser/page checks need no provider credential. GitHub Pages publication is a separate task.

Public references

• Claude plugin commands and preserved-data semantics
• Claude MCP project context and approvals
• Codex skills and MCP configuration
• systemd credential requirements

These references can change. Check your installed versions. The essential setup instructions on this page do not depend on private build-journal links.