Release v1.1.0

Author: HaShiShark

GITHUB_RELEASE.md

@@ -1,29 +1,24 @@
-# Codex Context Proxy v1.0.0
-
-A visual, editable context layer for Codex. Let AI edit AI's context with surgical precision, giving you more control and freedom over what Codex sees.
-
-## What's Included
-
-- Fixes for Python environment setup and dependency installation
-- `npm run setup:python` for creating and updating the local `.venv`
-- Test scripts now prefer the project `.venv` when available
-- Added Brotli and zstandard runtime dependencies for compressed responses
-- Visual context map for Codex sessions
-- Token overview for current context usage
-- Manual context inspection and editing panel
-- AI-assisted context compression for noisy tool output
-- More reliable compact/override handling after Codex `/compact`
-- Safer whole-node compression for tool-heavy assistant turns
-- Codex CLI support through `codex ctx proxy on/off/status`
-- Experimental Codex Desktop support through `codex ctx desktop on/off/status`
-- Windows installer with bundled Electron app and Python backend
+# Codex Context Studio v1.1.0
+
+A visual, editable context layer for Codex. This release focuses on the Context Studio identity, clearer bilingual documentation, and safer transcript rebuilding for newer Codex request metadata.
+
+## What's New
+
+- Renamed the user-facing project identity to Codex Context Studio
+- Reworked the English and Chinese READMEs with updated feature descriptions, architecture diagrams, and screenshots
+- Moved screenshots into language-specific folders for clearer documentation
+- Preserved Codex internal turn metadata and turn IDs when rebuilding request input
+- Added support for `custom_tool_call.namespace` during response-to-request projection
+- Improved compact request metadata detection across differently cased client metadata keys
+- Localized grouped tool-call labels in the context workbench
+- Expanded proxy core and cursor delta tests for metadata and request rebuild behavior
 
 ## Download
 
 Download and run:
 
 ```text
-Codex Context Proxy Setup 1.0.0.exe
+Codex Context Proxy Setup 1.1.0.exe
 ```
 
 After installation, open a new terminal and enable the proxy:

README.md

@@ -1,199 +1,208 @@
-# Codex Context Proxy
+<p align="center">
+  <img src="electron/assets/hash-icon.ico" alt="Codex Context Studio icon" width="128" height="128">
+</p>
 
-A visual, editable context layer for Codex. Let AI edit AI's context with surgical precision, giving you more control and freedom over what Codex sees.
+<h1 align="center">Codex Context Studio</h1>
 
-## What We Built
+<p align="center">
+  <strong>🧠 Context Control Panel for Codex</strong>
+  <br>
+  <sub>Make Codex's context visible, locatable, and precisely manageable — like memory.</sub>
+</p>
 
-Codex Context Proxy gives the official Codex CLI a visual and editable context layer.
+<p align="center">
+  <a href="#-core-features">Features</a> ·
+  <a href="#-architecture">Architecture</a> ·
+  <a href="#-quick-start">Install</a> ·
+  <a href="#-faq">FAQ</a>
+</p>
 
-Codex is powerful in long coding sessions, but its context can become hard to inspect and harder to maintain. Tool logs, failed attempts, outdated assumptions, and repeated transcript fragments can keep accumulating. When that happens, you usually cannot see exactly what Codex is about to read or selectively remove noisy context before the next response.
+<p align="center">
+  <a href="README.md">English</a> ·
+  <a href="README.zh-CN.md">中文</a>
+</p>
 
-This project adds a local context editor in front of Codex. You keep using the normal Codex workflow, while the proxy captures Codex's live context and opens a workbench where you can visualize, edit, compress, and delete context before future responses.
+<p align="center">
+  <img alt="Electron" src="https://img.shields.io/badge/electron-37-2f7f8f?style=flat-square&logo=electron&logoColor=white">
+  <img alt="Python" src="https://img.shields.io/badge/python-3.10%2B-3776ab?style=flat-square&logo=python&logoColor=white">
+  <img alt="React" src="https://img.shields.io/badge/react-19-149eca?style=flat-square&logo=react&logoColor=white">
+  <img alt="TypeScript" src="https://img.shields.io/badge/typescript-5.9-3178c6?style=flat-square&logo=typescript&logoColor=white">
+  <img alt="License" src="https://img.shields.io/badge/license-GPL--3.0-555?style=flat-square">
+  <img alt="Status" src="https://img.shields.io/badge/status-alpha-ff7a1a?style=flat-square">
+</p>
 
-In short:
 
-```text
-Codex writes code.
-Codex Context Proxy helps maintain Codex's context.
-```
-
-## What Codex Gets
+---
 
-- Context visualization: see the conversation, tool history, and context nodes Codex is about to use.
-- Editable context: compress, delete, or rewrite selected context items.
-- AI context editing: use a second AI pass to maintain the main AI's context.
-- Precise compaction: replace blunt auto-compact with targeted context surgery.
-- CLI and Desktop support: use it with Codex CLI, with experimental support for Codex Desktop.
-- Normal workflow: continue using Codex from the terminal or desktop app.
+## ⚡ In One Line
 
-The context editing workbench is adapted from HashCode. The original project explains the broader "AI edits AI's context" idea in more detail:
+This project lets you see Codex's context consumption, what's retained after compression, and edit it yourself. It also lets you replace Codex's system prompt to break through Codex's limitations, and replace Codex's compression prompt for better compressed output.
 
-https://github.com/HaShiShark/context-editor-agent
+---
 
-## Screenshots
+## 🎯 Core Features
 
-### Visualize Codex Context and Token Usage
+### 🔬 Context Visualization — See Inside Codex's Brain
 
-![Visualize Codex Context](docs/images/context-map.png)
+> View Codex's context by role, check token usage per turn, and see when prompts are injected.
 
-### Ask AI to Inspect the Current Context
+### ✂️ Context Management — Take Over Codex's Memory
 
-![Edit Context With AI](docs/images/context-workbench.png)
+> Chat with a dedicated secondary model to analyze, edit, compress, and manage the main Codex's context. You can plug in a cheap secondary model.
 
-### Compress Noisy Tool Context
+### 📈 Usage Panel — How Much Did This Session Cost?
 
-![Compress Context](docs/images/context-compress.png)
+> View token consumption, cache hit rate, and estimated cost across your Codex session.
 
-## Features
+### 🔀 Prompt Replacement — Rewrite Codex's Default Prompts
 
-### Live Context Map
+> Replace Codex's system prompt and native compression prompt for jailbreaking and better compression quality.
 
-Codex Context Proxy converts a Codex session into a structured context map. Instead of treating the transcript as one long wall of text, it shows user turns, assistant turns, tool calls, tool results, and edited context nodes as separate items.
+### 🔌 Local Proxy — Transparent, Non-Invasive
 
-### AI-Assisted Context Editing
+> No Codex source code changes, no official tools replaced. Sits in the middle as a local proxy, compatible with all native features.
 
-You can select noisy or outdated context and ask an editor model to compress, rewrite, or clean it up. This makes it possible to preserve useful intent while removing bulk from logs, failed attempts, or repeated information.
+---
 
-### Manual Context Control
+## 📸 Screenshots
 
-Not every context edit needs AI. You can also remove selected nodes or inspect raw content manually.
+### Context Map & Secondary Model Chat
 
-### Codex CLI and Desktop
+![Context map and secondary model chat](docs/images/eng/1.png)
 
-Codex CLI support is the main path. Once enabled, the normal `codex` command starts the local proxy and context window before launching the real Codex CLI.
+### Context Compression Result
 
-Codex Desktop support is also included. It can point Codex Desktop's model provider configuration at the local proxy so desktop conversations can use the same editable context layer. Desktop support touches local Codex configuration, so it is controlled separately from the CLI switch.
+![Context compression result](docs/images/eng/2.png)
 
-### Transparent Workflow
+### Prompt Replacement
 
-When the proxy is off, `codex` passes through to the official Codex CLI. When the proxy is on, the same `codex` command starts the local proxy, opens the context window, and then launches the real Codex CLI.
+![Prompt replacement](docs/images/eng/3.png)
 
-## How It Works
+### Usage Panel
 
-Codex Context Proxy runs a local Responses API compatible proxy.
+![Usage panel](docs/images/eng/4.png)
 
-When Codex sends a request, the proxy captures the request body and response stream, then builds a canonical transcript for the context workbench. If you do not edit anything, requests are forwarded transparently and Codex behaves like normal.
+---
 
-When you edit the context, the proxy replaces that session's canonical transcript. On the next Codex turn, it diffs Codex's new raw `input` against the cursor, appends the new tail, and rebuilds the upstream Responses `input` from the edited transcript.
+## 🏗️ Architecture
 
-High-level flow:
+```mermaid
+flowchart LR
+    CD["Codex CLI / Desktop"]
+    PX["Responses Proxy\n:8787"]
+    WEB["Web Backend\n:8765"]
+    FE["React Workbench"]
+    OAI["OpenAI API / Upstream Model"]
 
-```text
-codex
-  -> local shim
-  -> Codex Context Proxy
-  -> official Codex request
-  -> OpenAI / ChatGPT Codex backend
+    CD -- "POST /v1/responses" --> PX
+    PX -- "Rebuilt request" --> OAI
+    OAI -- "SSE stream" --> PX
+    PX -- "SSE stream" --> CD
 
-context window
-  -> visualize transcript
-  -> edit selected nodes
-  -> save edited context
-  -> next Codex turn uses edited context
+    FE -- "HTTP edit/settings" --> WEB
+    WEB -- "HTTP proxy control" --> PX
+    PX -. "WebSocket realtime events" .-> FE
 ```
 
-## Quick Start
+**How It Works:**
 
-Download and run the Windows installer:
+Every Codex request follows the same path — there is no "pass-through if unedited" branch:
 
-```text
-Codex Context Proxy Setup 1.0.0.exe
+```mermaid
+flowchart LR
+    A["Codex sends request"] --> B["cursor diff"] --> C["Update transcript"] --> D["Rebuild input"] --> E["Forward upstream"]
 ```
 
-After installation, open a new terminal and enable the proxy:
-
-```powershell
-codex ctx proxy on
-```
+- **Transcript** is the single source of truth: what users see in the workbench, edit, and what ultimately gets sent upstream
+- **Without edits**, the rebuilt input is naturally equivalent to the original Codex input
+- **With edits**, upstream receives the edited transcript + new content from the current turn
+- **During compression**, Codex's native compression prompt is replaced with a custom version, and the result is written back to the transcript
 
-Use Codex normally:
+---
 
-```powershell
-codex
-```
+## 🚀 Quick Start
 
-Disable the proxy anytime:
+**1. Install**
 
-```powershell
-codex ctx proxy off
-```
+Download and run the latest Windows installer from [Releases](https://github.com/nicobailon/codex-context-studio/releases).
 
-Check status:
+**2. Enable CLI Proxy**
 
 ```powershell
-codex ctx proxy status
+codex ctx proxy on      # Enable proxy
+codex                   # Use Codex normally
+codex ctx proxy status  # Check status
+codex ctx proxy off     # Disable proxy
 ```
 
-Remove the shim:
+**3. Desktop Support**
 
 ```powershell
-codex ctx proxy uninstall
+codex ctx desktop on      # Enable Desktop mode
+codex ctx desktop status  # Check status
+codex ctx desktop off     # Disable
 ```
 
-### Codex Desktop
+> [!NOTE]
+> Desktop mode modifies local Codex provider configuration. CLI mode only adds a shim and does not affect any config files.
+
+---
 
-Desktop support is controlled separately:
+## 🛠️ Development
 
 ```powershell
-codex ctx desktop on
-```
+# Install dependencies
+npm install
+npm run setup:python
 
-Check Desktop proxy status:
+# Run the full local flow
+npm run codex
 
-```powershell
-codex ctx desktop status
-```
+# Run only the context window
+npm run window
 
-Disable Desktop proxying:
+# Run checks
+npm run typecheck
+npm test
 
-```powershell
-codex ctx desktop off
+# Build Windows installer
+npm run dist:win
 ```
 
-Desktop support is more experimental than CLI support because it modifies local Codex configuration instead of only adding a command shim.
+---
 
-## Development
+## ❓ FAQ
 
-Install dependencies:
+<details>
+<summary><strong>Is this a Codex plugin?</strong></summary>
 
-```powershell
-npm install
-npm run setup:python
-```
+No. Codex Context Studio is a local context layer around Codex, implemented through proxy technology.
 
-Run the local Codex flow:
+</details>
 
-```powershell
-npm run codex
-```
+<details>
+<summary><strong>Will it break the cache?</strong></summary>
 
-Run only the context window:
+Compression is not a frequent event. After compression, it only recalculates once, which is more cost-efficient than carrying useless context. In practice, cache hit rate only drops by 5–10%.
 
-```powershell
-npm run window
-```
+</details>
 
-Run type checks:
+<details>
+<summary><strong>Why not just rely on auto-compaction?</strong></summary>
 
-```powershell
-npm run typecheck
-```
+Compatible with native compression. The project also helps replace compression prompts — we've built more precise, targeted compression features.
 
-Build the Windows installer:
+</details>
 
-```powershell
-npm run dist:win
-```
+<details>
+<summary><strong>Who is this for?</strong></summary>
 
-The installer is generated at:
+People who want better control over context, have their own ideas about compression, or want to modify Codex's prompts.
 
-```text
-release/Codex Context Proxy Setup 1.0.0.exe
-```
+</details>
 
-## Notes
+---
 
-- This project does not replace Codex.
-- It does not require modifying the official Codex CLI source code.
-- It works by adding a local editable context layer in front of Codex.
-- Codex Desktop support is more experimental than Codex CLI support.
+<p align="center">
+  <sub>GPL-3.0 · Made with ❤️ for Codex power users</sub>
+</p>