@christiandoxa/prodex-win32-x64

Managed Mem0 mode is still local-first:

• Prodex clones https://github.com/mem0ai/mem0 under $PRODEX_HOME/mem0 if needed.
• Prodex writes the Mem0 server .env with generated local ADMIN_API_KEY, JWT_SECRET, and Postgres password.
• Mem0 auth stays enabled; Prodex keeps the local API key internal and injects it only into the temporary MCP overlay.
• Mem0 receives OPENAI_BASE_URL=http://host.docker.internal:<prodex-gateway-port>/v1.
• Mem0 receives an internal Prodex gateway bearer token as OPENAI_API_KEY.
• The gateway selects an efficient memory LLM when available, preferring nano/mini models, and defaults embeddings to text-embedding-3-small.
• If no upstream API-key profile is available, the internal gateway still serves deterministic local embeddings for Mem0 and disables generation endpoints for that Mem0-only gateway.
• Prodex writes raw/no-infer memories by default, so the managed path does not spend LLM quota for memory extraction.
• No Mem0 Cloud endpoint and no user-managed MEM0_API_KEY are used.

Use prodex s doctor to verify that the built-in memory store can be opened before launching Codex. The hidden MCP server can also be launched directly for diagnostics:

prodex s doctor
prodex __memory-mcp --store /tmp/prodex-memory.sqlite

Mem0 Cloud's official MCP endpoint is intentionally not part of Prodex Super's default path. Configure it manually only when you explicitly want Mem0 Platform auth and are willing to manage MEM0_API_KEY yourself.

Prodex can route requests with --language-mode auto --languages en,id, but Indonesian (id) detection only works if the Analyzer supports Indonesian NLP configuration and recognizers. The default Microsoft Analyzer image is usually English-only, so build a custom Analyzer and keep the standard Anonymizer.

Minimal local Analyzer example:

mkdir -p ~/.local/share/presidio-id-analyzer
cd ~/.local/share/presidio-id-analyzer

cat > Dockerfile <<'EOF'
FROM python:3.11-slim
RUN pip install --no-cache-dir flask gunicorn presidio-analyzer spacy \
 && python -m spacy download en_core_web_sm \
 && python -m spacy download xx_ent_wiki_sm
WORKDIR /app
COPY app.py /app/app.py
CMD ["gunicorn", "-b", "0.0.0.0:3000", "app:app"]
EOF

cat > app.py <<'EOF'
from flask import Flask, jsonify, request
from presidio_analyzer import AnalyzerEngine, Pattern, PatternRecognizer, RecognizerRegistry
from presidio_analyzer.nlp_engine import NlpEngineProvider
from presidio_analyzer.predefined_recognizers import EmailRecognizer, UrlRecognizer

nlp_config = {
    "nlp_engine_name": "spacy",
    "models": [
        {"lang_code": "en", "model_name": "en_core_web_sm"},
        {"lang_code": "id", "model_name": "xx_ent_wiki_sm"},
    ],
}
nlp_engine = NlpEngineProvider(nlp_configuration=nlp_config).create_engine()
registry = RecognizerRegistry(supported_languages=["en", "id"])
registry.load_predefined_recognizers(nlp_engine=nlp_engine, languages=["en", "id"])
registry.add_recognizer(EmailRecognizer(supported_language="id"))
registry.add_recognizer(UrlRecognizer(supported_language="id"))

registry.add_recognizer(PatternRecognizer(
    supported_entity="PHONE_NUMBER",
    language="id",
    patterns=[Pattern("id mobile phone", r"(?<!\d)(?:\+62|62|0)8[1-9][\d\s.-]{7,13}\d(?!\d)", 0.75)],
    context=["telepon", "nomor", "hp", "ponsel"],
))
registry.add_recognizer(PatternRecognizer(
    supported_entity="ID_INDONESIA_NIK",
    language="id",
    patterns=[Pattern("nik", r"(?<!\d)\d{16}(?!\d)", 0.75)],
    context=["nik", "ktp"],
))
registry.add_recognizer(PatternRecognizer(
    supported_entity="ID_INDONESIA_NPWP",
    language="id",
    patterns=[Pattern("npwp", r"(?<!\d)\d{2}\.?\d{3}\.?\d{3}\.?\d[-.]?\d{3}\.?\d{3}(?!\d)", 0.75)],
    context=["npwp", "pajak"],
))
registry.add_recognizer(PatternRecognizer(
    supported_entity="PERSON",
    language="id",
    patterns=[Pattern("nama saya", r"(?i)\b(?:nama saya|saya bernama|nama)\s+[A-Z][A-Za-z.'-]*(?:\s+[A-Z][A-Za-z.'-]*){0,3}", 0.85)],
    context=["nama", "saya", "bernama"],
))

analyzer = AnalyzerEngine(
    nlp_engine=nlp_engine,
    registry=registry,
    supported_languages=["en", "id"],
)
app = Flask(__name__)

@app.get("/health")
def health():
    return jsonify({"status": "ok"})

@app.post("/analyze")
def analyze():
    body = request.get_json(force=True)
    results = analyzer.analyze(
        text=body["text"],
        language=body.get("language", "en"),
        entities=body.get("entities"),
        score_threshold=body.get("score_threshold", 0),
    )
    return jsonify([result.to_dict() for result in results])
EOF

docker build -t prodex-presidio-analyzer-id:latest .
docker rm -f presidio-analyzer presidio-anonymizer 2>/dev/null || true
docker run -d --name presidio-analyzer -p 5002:3000 prodex-presidio-analyzer-id:latest
docker run -d --name presidio-anonymizer -p 5001:3000 mcr.microsoft.com/presidio-anonymizer:latest

prodex presidio enable --language-mode auto --languages en,id

This example keeps built-in recognizers such as EMAIL_ADDRESS and URL, adds Indonesian phone numbers, NIK, NPWP, and context-based PERSON detection for text like Nama saya Budi.

If the containers do not appear in Docker Desktop, check the active Docker context. Docker Desktop usually uses desktop-linux.

docker context show
docker context ls
docker --context desktop-linux ps -a --filter name=presidio

Before launch, Super asks whether to add Presidio redaction. Empty input or n keeps the expansion above. If you answer y, it is equivalent to:

prodex caveman rtk sqz tokensavior clawcompactor ponytail presidio --full-access

Use prodex super --presidio to enable Presidio without prompting, or prodex super --no-presidio to skip the prompt and keep Presidio disabled. Presidio enables runtime request-body and WebSocket text redaction through local Presidio for the session when services are healthy; service failures follow fail_mode. The runtime uses presidio.toml endpoints when configured, falls back to http://localhost:5002 and http://localhost:5001, and honors fail_mode = "open" or "closed".

After the Presidio prompt, Super asks whether to enable prodex-memory through managed Mem0 Docker. Empty input or n leaves prodex-memory disabled, so Codex will not wait for that MCP server. Answer y or pass --mem0 to start the managed Mem0 OSS Docker server, route its OpenAI-compatible calls through a session-local Prodex gateway, and inject the local Mem0 API key into the temporary Codex MCP config. Use --no-mem0 to skip the prompt. Use the mem optimizer prefix for local SQLite memory. This path does not use Mem0 Cloud or MEM0_API_KEY; Docker Compose is required, and Prodex falls back to local embeddings when no upstream provider API key is available.

Super prints prelaunch progress for runtime proxy setup, Presidio auto-start/checks, and managed Mem0 Docker startup. The output happens before Codex starts; runtime notices still go to logs once the TUI is running.

Full access maps to Codex's sandbox-bypass launch flag. Use it only when you intentionally want Codex to run without the normal approval and sandbox protections.

Use prodex s doctor to inspect the Super optimizer stack without launching Codex. Add --json for machine-readable output, --strict to exit non-zero when any optimizer check is unavailable, and --presidio to include local Presidio Analyzer/Anonymizer health checks. prodex s --dry-run also prints the same optimizer matrix for the launch preview.

Use prodex s expose when you need to reach the live Super terminal from a browser. Prodex starts a local PTY bridge protected by a high-entropy access token, launches cloudflared tunnel --protocol http2 --url ... when cloudflared is available, and prints both the loopback and Cloudflare quick-tunnel URLs. The browser tab can close without stopping the session; reopening the same token URL reconnects to the existing PTY and replays recent scrollback. Add --no-tunnel for local-only access, --max-clients N to cap simultaneous browsers, or --command 'prodex s --no-presidio' to choose the initial terminal command.

Super's built-in optimization stack is deliberately local and deterministic. It preloads Caveman, exposes a Prodex overlay rtk PATH wrapper plus RTK auto-wrappers for common noisy commands when RTK is installed, auto-registers built-in prodex-inspect plus discovered sqz-mcp, token-savior, and codebase-memory-mcp MCP servers, exposes sqz and claw-compactor wrapper commands when those commands/checkouts are discoverable, installs a trusted one-shot prodex-claw-compactor-sessionstart SessionStart benchmark probe wrapper when Claw-Compactor is available, then uses Smart Context Autopilot through a dedicated runtime proxy for lower-token request shaping. The claw startup probe is disabled by default so Codex launch is not delayed; opt in with PRODEX_CLAW_SESSIONSTART_TIMEOUT_SECONDS=<seconds>. When enabled, it delegates to prodex-claw-compactor-auto "$(pwd)", uses a marker under CODEX_HOME so Codex conversation restarts do not replay it, and falls back to a temporary shadow MEMORY.md when the workspace has no Markdown memory files. Presidio redaction and prodex-memory are added only when you opt in. Prodex routes optional-tool state under PRODEX_HOME (default ~/.prodex), including SQZ XDG state, token-savior cache/stats, Codebase Memory cache/config, claw-compactor HOME/XDG state, RTK analytics paths, and local memory, so compatible optimizer metadata stays out of worktrees.

Smart Context treats protocol and continuation metadata as exact control-plane data while allowing independent context payload segments to remain eligible for deterministic lossless or artifact-backed rewriting. Explicit exact mode still makes the complete request pass through. Missing artifact references are handled as segment-local rehydration failures: the dependent reference is preserved and recorded, budgets tighten, and unrelated payload segments may still be optimized when validation proves continuation identifiers, tool-call structure, critical signals, and JSON integrity are intact.

Smart Context budgeting is model-relative: it calculates pressure from effective used tokens against the usable context window after output reserve, records pressure bands and estimator confidence, and tightens behavior when runtime token accounting is uncertain. Context window selection prefers explicit launch config, then a versioned provider/model registry, then observed runtime accounting and conservative fallback behavior.

Smart Context rollout controls are local environment flags. PRODEX_SMART_CONTEXT_CANARY_PERCENT=N deterministically applies rewriting only for the selected percentage of requests, while canary-out requests pass through unchanged and log rollout_canary_out. PRODEX_SMART_CONTEXT_SHADOW=1 computes Smart Context diagnostics and telemetry while returning the original request upstream. Explicit exact mode still bypasses rollout and remains full pass-through.

Smart Context replay evaluation is modeled in the runtime proxy so saved JSON corpora can be scored deterministically against the rollout gate: median token reduction, long-session coverage, success regression, continuation/tool/critical-signal integrity, unresolved mandatory artifact references, JSON corruption, rewrite overhead, and full-request fallback rate.

See docs/smart-context.md for the safety model, telemetry fields, rollout flags, migration note, and current replay benchmark report.

Super instructs Codex to use the available local optimizer stack where it fits the task, not just RTK:

• RTK works upstream/input-side. Use visible rtk <cmd> for noisy terminal commands before their output enters the model context, such as git diff, cargo test, npm test, build logs, and package-manager output. Prodex also auto-wraps common noisy commands as a fallback when RTK is installed, but that fallback does not make the TUI show an rtk prefix.
• SQZ works downstream/context-side through the auto-registered prodex-sqz MCP server when sqz-mcp is available. Use it for repeated workspace reads, large text blobs, long command outputs that need reuse, and long-session context compression instead of emitting the same full content again.
• token-savior handles symbol lookup, caller/context navigation, duplicate/dead-code checks, and API-impact searches before broad source reads when token-savior is available.
• codebase-memory-mcp handles structural codebase graph queries such as architecture, call chains, impact analysis, dead-code lookup, and cross-service links when the binary is available.
• prodex-inspect provides read-only MCP diagnostics for Prodex status, profiles, and latest runtime log tail.
• claw-compactor handles workspace-level summary or benchmark requests through prodex-claw-compactor / prodex-claw-compactor-auto when available; treat its output as overview context and reread exact source before edits.
• Ponytail loads the local DietrichGebert/ponytail Codex plugin into the temporary overlay when the checkout exists under a managed optimizer root, adding smallest-correct-implementation pressure without changing the base Codex profile.
• prodex-memory provides local Mem0-style memory through the mem prefix with SQLite, or through managed Mem0 OSS Docker when you opt in with the Super prompt or --mem0; neither path uses Mem0 Cloud auth or MEM0_API_KEY.
• Presidio stays optional and only runs when you opt in with the Super prompt or --presidio.

Managed optimizer checkouts are discovered from PRODEX_OPTIMIZERS_HOME, $XDG_DATA_HOME/prodex-optimizers, then ~/.local/share/prodex-optimizers. Put Ponytail at ~/.local/share/prodex-optimizers/ponytail with git clone https://github.com/DietrichGebert/ponytail.git ~/.local/share/prodex-optimizers/ponytail. The generated SUPER_OPTIMIZERS.md overlay includes an Available Now section so the model can see which MCP servers and wrappers were actually discovered for that session.

Use --provider anthropic when you want the Codex/Super front end with Anthropic upstream:

prodex login --with-claude
prodex s --provider anthropic --model claude-sonnet-4-6
prodex s --provider anthropic --model claude-sonnet-4-6 --api-key "$ANTHROPIC_API_KEY"

If --api-key is omitted, Prodex uses the Anthropic profile created by prodex login --with-claude or prodex profile import claude. API-key mode still reads ANTHROPIC_API_KEY; ANTHROPIC_API_KEYS may contain multiple comma-, semicolon-, or newline-separated keys for round-robin request rotation and pre-commit retry on auth/quota/rate/temporary failures. This path injects a temporary prodex-anthropic Codex provider, exposes a local /v1/responses adapter to Codex, forwards to Anthropic's OpenAI-compatible chat API, and keeps quota preflight disabled. prodex quota --all --provider anthropic shows OAuth readiness for Anthropic profiles; set ANTHROPIC_ADMIN_KEY when you want Anthropic Admin rate-limit groups included.

Use --provider copilot when you want the Codex/Super front end with GitHub Copilot upstream:

prodex profile import copilot
prodex s --provider copilot --model gpt-5.3-codex

Without --api-key, Prodex uses imported Copilot CLI profiles, refreshes Copilot runtime API tokens from GitHub before launch, can rotate fresh native Responses requests across multiple eligible profiles, and binds streaming response IDs back to the owning profile for continuations. GITHUB_COPILOT_API_KEY, GITHUB_COPILOT_API_KEYS, or --api-key can be used when you already have Copilot runtime API token(s); plural keys may be comma-, semicolon-, or newline-separated and can rotate before commit on auth/quota/rate/temporary failures.

Use --provider deepseek when you want the Codex/Super front end with DeepSeek as the upstream model:

prodex s deepseek --model deepseek-v4-pro --api-key "$DEEPSEEK_API_KEY"

If --api-key is omitted, Prodex reads DEEPSEEK_API_KEY; DEEPSEEK_API_KEYS may contain multiple comma-, semicolon-, or newline-separated keys for round-robin request rotation and pre-commit retry on auth/quota/rate/temporary failures. This path injects a temporary prodex-deepseek Codex provider, exposes a local /v1/responses adapter to Codex, forwards to DeepSeek's OpenAI-format chat API, and keeps quota preflight disabled. Prodex also injects a one-model Codex catalog for the selected DeepSeek model, so /model stays on that model and offers the DeepSeek-compatible high/xhigh effort choices. prodex quota --all --provider deepseek reads the same DEEPSEEK_API_KEY(S) environment and fetches DeepSeek /user/balance. Available Super optimizer tools remain local Prodex overlay additions around Codex. Remote compact is not implemented for this adapter yet, so the default DeepSeek context window is large and --auto-compact-token-limit defaults high.

The DeepSeek catalog includes deepseek-v4-pro and deepseek-v4-flash; deepseek-chat and deepseek-reasoner remain compatibility aliases for existing configs.

DeepSeek compatibility is translated, not native Responses. Prodex maps Codex text turns, function/MCP/local shell/apply-patch style tools, tool_choice, reasoning effort, JSON object mode, stop sequences, token limits (max_output_tokens, max_tokens, and max_completion_tokens), sampling, logprobs, streaming usage, and DeepSeek cache hit/miss usage into compatible shapes. Request metadata, client_metadata, prompt_cache_key, and prompt_cache_retention are preserved in local response metadata instead of being forwarded upstream. JSON schema requests are degraded to DeepSeek json_object mode and marked in response metadata because DeepSeek's OpenAI Chat route does not provide native JSON Schema enforcement. Web search is explicit and configurable: the DeepSeek catalog does not advertise native Codex web search, [deepseek] web_search_mode = "auto" fails clearly because DeepSeek's OpenAI Chat docs do not document native web-search request fields, "off" rejects web-search tools, and "openai_chat" explicitly chooses best-effort web_search_options forwarding with retry fallback. Gateway/profileless launches can use PRODEX_DEEPSEEK_WEB_SEARCH_MODE. The reserved anthropic and function_proxy modes fail clearly until the DeepSeek Anthropic adapter or a local search backend is implemented. DeepSeek function tools are bounded by the upstream 128-tool limit; Prodex must fail rather than silently truncate if that ceiling is reached, translated duplicate tool names are rejected instead of being dropped, and named tool_choice must target a translated function tool. Tool declarations must also be translatable: function/custom tools require names, namespace tools require a named namespace with named function entries, MCP toolsets that declare inventories require a server name plus allowed/enabled tools, and DeepSeek function names must use only letters, numbers, underscores, or dashes within the upstream 64-character limit. When DeepSeek thinking is enabled, Prodex omits explicit tool_choice for upstream compatibility and records the omitted value in DeepSeek response metadata. Reasoning content, refusal text, annotations, logprobs, and finish reasons are preserved in DeepSeek response metadata. Reasoning summaries are not advertised for DeepSeek, and reasoning.summary fails clearly. Image, document, audio, and video message content is rejected because this adapter targets DeepSeek's text/tool OpenAI Chat surface. Deprecated frequency_penalty and presence_penalty are not mapped because current DeepSeek docs mark them unsupported/ignored. parallel_tool_calls=true is compatible with DeepSeek's one-or-more tool-call behavior, but parallel_tool_calls=false is rejected because the OpenAI Chat route has no equivalent control to enforce it. Responses-only controls that DeepSeek cannot honor, including non-empty include, store=false, background responses, truncation=auto, per-message cache_control, text.verbosity, legacy functions/function_call, logit_bias, and max_tool_calls, fail clearly instead of being dropped.

DeepSeek troubleshooting: if JSON mode appears to stream whitespace or stalls, make sure the prompt explicitly asks for JSON; Prodex adds a minimal adapter instruction when JSON mode is requested, but model-facing task instructions still matter. A DeepSeek 400 around web search usually means the selected openai_chat web-search forwarding shape is not accepted by upstream; use web_search_mode = "off" or remove web-search tools unless you are deliberately testing that best-effort path. Strict tool failures usually mean a schema keyword outside DeepSeek's beta strict subset, a missing required property, or an object schema that cannot be made additionalProperties = false.

DeepSeek compatibility matrix:

Strict DeepSeek function calling is opt-in because DeepSeek documents it on the beta endpoint. Add this to the selected Codex profile config:

[deepseek]
strict_tools = true
beta_base_url = "https://api.deepseek.com/beta"

Gateway/profileless launches can use PRODEX_DEEPSEEK_STRICT_TOOLS=1 and optional PRODEX_DEEPSEEK_BETA_BASE_URL. When enabled, Prodex routes rewritten DeepSeek /responses traffic through the beta base URL, sets every translated function tool to strict: true, forces strict object schemas to require all properties with additionalProperties = false, and rejects unsupported strict schema keywords or types clearly. DeepSeek beta chat prefix completion and FIM /completions are not enabled by this adapter yet; prefix, prompt, and suffix completion-style requests fail fast instead of being rewritten as chat.

Use --provider gemini when you want the Codex/Super front end with Gemini upstream:

prodex login --with-google
prodex s gemini
prodex s gemini --cli gemini
prodex s gemini --cli agy
GEMINI_API_KEY=... prodex s gemini --model gemini-2.5-pro
prodex s gemini --model gemini-2.5-pro --api-key "$GEMINI_API_KEY"

Without --api-key, Prodex uses the Google OAuth profile created by prodex login --with-google or the interactive Google sign-in choice, then routes through Google's Code Assist Gemini endpoint. Google login verifies Code Assist readiness before creating or updating the profile, and may open a second browser page if Google requires account verification. With --api-key, or GEMINI_API_KEY(S) / GOOGLE_API_KEY(S), Prodex converts Codex Responses requests to Chat Completions and sends them through Google's documented /v1beta/openai/chat/completions endpoint with Bearer authentication. Streaming, function calls, continuations, and Gemini reasoning_effort values are converted back into Codex Responses semantics. Plural key env vars may be comma-, semicolon-, or newline-separated and can rotate before commit on auth/quota/rate/temporary failures. OAuth sessions keep fresh Gemini requests sticky to the previous successful profile by default for smoother Codex-style continuity; set PRODEX_GEMINI_STICKY_FRESH_OAUTH=0 to restore pure fresh-request round robin. The default model is auto, matching Gemini CLI-style model routing through Gemini 3 and stable fallbacks; launch-time Gemini modelConfigs / modelIdResolutions / modelChains are projected into the Codex catalog and runtime fallback snapshot when configured. The injected catalog exposes Gemini reasoning efforts with the 2.5 default thinking budget of 8192 where budget mode is used. prodex quota reads the same Google OAuth profile and fetches Gemini Code Assist retrieveUserQuota bucket data. Available Super optimizer tools remain local Prodex overlay additions around Codex on this path.

prodex s gemini --cli gemini launches the native Google Gemini CLI instead of Codex, defaults its native tools to YOLO approval mode, and routes Code Assist requests through Prodex OAuth profile routing. This native CLI path currently requires a Google OAuth profile and does not accept --api-key. Set PRODEX_GEMINI_BIN to override the gemini executable.

prodex s gemini --cli agy launches the native Antigravity CLI with --dangerously-skip-permissions so tool permission prompts are auto-approved. Antigravity CLI owns its authentication through the system keyring/Google Sign-In and does not expose an endpoint or token override, so Prodex account auto-rotation and Presidio proxying are not available on this path. Set PRODEX_AGY_BIN to override the agy executable.

The OAuth bridge also maps native Gemini computerUse, code execution, grounding/citation/URL-context metadata, generated images, video metadata, multimodal file inputs, log-probability metadata, tool-use and cached-token accounting, safety metadata, and Gemini finish reasons into Codex-compatible request, response, and SSE shapes. Citations are emitted as a separate completed output item after Gemini supplies a finish reason. Assistant followups retain native Gemini code, media, video, cache, and thought-signature parts without replaying citation display text as model history.

@path and bounded read_many_files context honor default binary/build/dependency exclusions plus ordered root .gitignore, .geminiignore, and custom ignore files, including later negation overrides. Large tool outputs are masked before replaying them into Gemini history and are written to PRODEX_GEMINI_TOOL_OUTPUT_DIR or the OS temp directory; set PRODEX_GEMINI_TOOL_OUTPUT_MASK_THRESHOLD=0 to disable this guard. Codex /responses/compact requests use a tool-free unary Gemini semantic-compaction turn on the Gemini CLI chat-compression-default alias and return Codex replacement history; a bounded deterministic local summary is used only when semantic compaction fails before commit. Invalid pre-commit Gemini streams are retried with bounded backoff before model fallback.

Gemini CLI compatibility helpers accept inline gemini_memory / gemini_policy / gemini_session request metadata, file-based gemini_*_file imports, and PRODEX_GEMINI_SESSION_FILE or PRODEX_GEMINI_CHECKPOINT_FILE import paths. Gemini memory is loaded by default from ~/.gemini/GEMINI.md, ancestor GEMINI.md files, .gemini/memory/MEMORY.md, and .gemini/memory/INBOX.md; set PRODEX_GEMINI_DISABLE_MEMORY=1, PRODEX_GEMINI_DISABLE_CONTEXT_FILES=1, or request metadata gemini_load_memory=false to opt out. Gemini settings are read in CLI precedence order from system defaults, global, ancestor project, cwd-local, and system override settings, honoring GEMINI_CLI_HOME, GEMINI_CLI_SYSTEM_SETTINGS_PATH, and GEMINI_CLI_SYSTEM_DEFAULTS_PATH; extension manifests and extension policy TOML files are also read when present to apply Gemini tool allow/exclude, hard command-specific tool-call blocking, and defaultApprovalMode behavior.

Before Codex launches, the Gemini provider projects Gemini CLI settings and extension surfaces into the active CODEX_HOME: system/global/project mcpServers and extension mcpServers become generated Codex [mcp_servers.gemini_*] entries with settings taking precedence over extension servers of the same Gemini name; system/global/project and extension command hooks are merged into hooks.json for Codex /hooks review; ~/.gemini/commands, project .gemini/commands, and extension commands/*.toml become Codex custom prompts with Gemini command aliases preserved where possible; extension skills/*/SKILL.md are copied into generated Codex skill folders under .agents/skills; and extension agents/*.md become generated Codex custom agents under agents/*.toml. Built-in /prompts:gemini-refresh, /prompts:gemini-memory-show, /prompts:gemini-memory-refresh, /prompts:gemini-memory-inbox, /prompts:gemini-remember, /prompts:gemini-checkpoint-create, /prompts:gemini-checkpoint-restore, /prompts:gemini-checkpoint-export, and /prompts:gemini-rewind cover reload/admin, memory, and checkpoint workflows. Generated helper scripts in CODEX_HOME/bin include prodex-gemini-refresh, prodex-gemini-checkpoint-create, and prodex-gemini-checkpoint-restore. Set PRODEX_GEMINI_EXTENSIONS=none or an allow-list of extension names to control extension loading, PRODEX_GEMINI_EXTENSION_DIRS to add extension roots, or PRODEX_GEMINI_DISABLE_CLI_COMPAT=1 to skip the launch-time Codex surface projection.

Gemini Live realtime websocket translation remains available for compatible callers and credentialed adapter tests, mapping Codex audio, transcript, text, function-call, function-result, interruption, cancellation, housekeeping, and turn-completion events to and from Gemini BidiGenerateContent; one Gemini auth/profile is selected before upgrade and remains fixed for the session. Codex 0.140.0 removed the upstream TUI voice controls, so this bridge should not be treated as a normal Codex TUI voice feature. PRODEX_GEMINI_LIVE_MODEL overrides the default Live model, while PRODEX_GEMINI_LIVE_URL is available for a custom or test Live endpoint. prodex doctor --runtime recognizes provider bridge and Gemini markers such as local_rewrite_provider_model_fallback, local_rewrite_gemini_quota_rotate, local_rewrite_gemini_invalid_stream_retry, and local_rewrite_gemini_live_error.

Run npm run test:gemini-schema after changing Gemini request, response, SSE, semantic compact, exact-output, tool-schema, or Live translation. Run PRODEX_LIVE_GEMINI=1 npm run test:gemini-live for a credentialed end-to-end Gemini adapter smoke request; set PRODEX_BIN or PRODEX_LIVE_GEMINI_MODEL to override the binary or model. Add PRODEX_LIVE_GEMINI_EXTENDED=1 for command-output-only, file edit, apply_patch, reference-repo clone/inspection, optional-tool update discipline, semantic compact, and explicit exec resume checks. Add PRODEX_LIVE_GEMINI_MCP=1 and/or PRODEX_LIVE_GEMINI_MULTIMODAL=1 when the local environment should also exercise MCP and image-input paths.

Before launch, Super asks whether to add Presidio redaction. Empty input or n keeps Presidio disabled; answer y or pass --presidio to add the presidio prefix. Use --no-presidio to make the disabled choice explicit for non-interactive use. Super then asks whether to enable prodex-memory through managed Mem0 Docker. Empty input or n leaves prodex-memory disabled; answer y or pass --mem0 to start the managed Mem0 OSS Docker server and route its OpenAI-compatible calls through Prodex gateway. Use --no-mem0 to skip that prompt, or the mem prefix for local SQLite memory.

Prodex now supports multi-language Presidio redaction, including automatic detection and multi-language merging. The runtime uses presidio.toml endpoints and language configuration when available, falling back to http://localhost:5002 and http://localhost:5001 for Analyzer/Anonymizer URLs, and English (en) for language if not specified. It honors fail_mode = "open" or "closed".

Example presidio.toml with multi-language support (English and Indonesian):

enabled = true
analyzer_url = "http://localhost:5002"
anonymizer_url = "http://localhost:5001"
language_mode = "auto"
languages = ["en", "id"]
fail_mode = "open"

Note that the default Microsoft Presidio Docker images typically only support English (en). To support other languages like Indonesian (id), you must use a custom Presidio Analyzer image with the necessary language models and recognizers installed. Prodex routing and configuration support the languages, but the actual detection quality depends on your Analyzer.

It keeps exact pass-through for continuation-sensitive requests. When safe, it uses adaptive token budgeting, artifact-backed large tool outputs, duplicate suppression, blob/noise detection, stable cache-friendly context framing, and critical-signal self-checks to reduce token load without dropping failure details.

The Super optimization stack is meant to stay deterministic and local by default. It auto-registers sqz-mcp, token-savior, and codebase-memory-mcp MCP servers when those binaries are already on PATH or in a managed prodex-optimizers checkout, loads Ponytail from a managed checkout when available, exposes sqz and claw-compactor wrappers when discoverable, routes compatible optimizer cache/state under PRODEX_HOME instead of the workspace, and uses a dedicated runtime proxy for local compaction, stable references, and lower-token context shaping rather than hidden remote summarization.

RTK handles upstream/input command output before it enters the context window, using visible rtk <cmd> commands and overlay auto-wrappers when available. Auto-wrappers are only a backstop; write rtk <cmd> explicitly when you want the TUI/transcript to show RTK usage. SQZ handles downstream/context reuse after content is already in the session, using prodex-sqz when the MCP server is available.

Managed optimizer checkouts are discovered from PRODEX_OPTIMIZERS_HOME, $XDG_DATA_HOME/prodex-optimizers, then ~/.local/share/prodex-optimizers; Ponytail is expected at ponytail/ inside one of those roots.