Rename codex-rs workspace and codex-acp package

Author: CSRessel

.github/codex/labels/codex-rust-review.md

@@ -15,8 +15,8 @@ Things to look out for when doing the review:
 
 ## Code Organization
 
-- Each create in the Cargo workspace in `codex-rs` has a specific purpose: make a note if you believe new code is not introduced in the correct crate.
-- When possible, try to keep the `core` crate as small as possible. Non-core but shared logic is often a good candidate for `codex-rs/common`.
+- Each create in the Cargo workspace in `nori-rs` has a specific purpose: make a note if you believe new code is not introduced in the correct crate.
+- When possible, try to keep the `core` crate as small as possible. Non-core but shared logic is often a good candidate for `nori-rs/common`.
 - Be wary of large files and offer suggestions for how to break things into more reasonably-sized files.
 - Rust files should generally be organized such that the public parts of the API appear near the top of the file and helper functions go below. This is analagous to the "inverted pyramid" structure that is favored in journalism.
 
@@ -131,7 +131,7 @@ fn test_get_latest_messages() {
 
 ## Pull Request Body
 
-- If the nature of the change seems to have a visual component (which is often the case for changes to `codex-rs/tui`), recommend including a screenshot or video to demonstrate the change, if appropriate.
+- If the nature of the change seems to have a visual component (which is often the case for changes to `nori-rs/tui`), recommend including a screenshot or video to demonstrate the change, if appropriate.
 - References to existing GitHub issues and PRs are encouraged, where appropriate, though you likely do not have network access, so may not be able to help here.
 
 # PR Information

.github/dependabot.yaml

@@ -8,8 +8,8 @@ updates:
       interval: weekly
   - package-ecosystem: cargo
     directories:
-      - codex-rs
-      - codex-rs/*
+      - nori-rs
+      - nori-rs/*
     schedule:
       interval: weekly
   - package-ecosystem: devcontainers
@@ -21,6 +21,6 @@ updates:
     schedule:
       interval: weekly
   - package-ecosystem: rust-toolchain
-    directory: codex-rs
+    directory: nori-rs
     schedule:
       interval: weekly

.github/workflows/cargo-deny.yml

@@ -10,7 +10,7 @@ jobs:
     runs-on: blacksmith-4vcpu-ubuntu-2404
     defaults:
       run:
-        working-directory: ./codex-rs
+        working-directory: ./nori-rs
     env:
       # Disable sccache wrapper from .cargo/config.toml since it's not available
       # in the cargo-deny Docker container.
@@ -26,7 +26,7 @@ jobs:
         uses: EmbarkStudios/cargo-deny-action@v2
         with:
           rust-version: nightly
-          manifest-path: ./codex-rs/Cargo.toml
+          manifest-path: ./nori-rs/Cargo.toml
           log-level: warn
           command: check
           arguments: --all-features

.github/workflows/docs.md

@@ -10,7 +10,7 @@ Path: @/.github/workflows
 
 ### How it fits into the larger codebase
 
-- The release workflow builds Rust binaries from `@/codex-rs/` and packages them via the Node.js launcher in `@/nori-cli/`
+- The release workflow builds Rust binaries from `@/nori-rs/` and packages them via the Node.js launcher in `@/nori-cli/`
 - Version detection delegates to `@/scripts/create_nori_release --get-next-version`, which queries git tags (via the GitHub API) as the single source of truth for version numbering
 - Stable releases use "synthetic commits" created by the `create_nori_release` script -- release tags point to commits that exist only for the release (not on any branch), with `Cargo.toml` updated to the release version, keeping the `main` branch's `Cargo.toml` at a placeholder `0.0.0`
 - The `nori-release.yml` workflow publishes to npm under the package name `nori-ai-cli`, with stable releases tagged `@latest` and snapshots tagged `@next`
@@ -25,7 +25,7 @@ Path: @/.github/workflows
 | Main branch push | Push to `main` (e.g., merged PR) with path filters | `publish_next=true` -- publishes a `@next` snapshot |
 | Manual dispatch | `workflow_dispatch` with inputs | Either `publish_next=true` or explicit version + optional `dry_run` |
 
-**Path filters for main branch pushes** restrict triggering to changes in `codex-rs/**`, `nori-cli/**`, `scripts/**`, and the workflow file itself, so docs-only changes do not trigger a release.
+**Path filters for main branch pushes** restrict triggering to changes in `nori-rs/**`, `nori-cli/**`, `scripts/**`, and the workflow file itself, so docs-only changes do not trigger a release.
 
 **Concurrency control** uses group `nori-release-${{ github.ref }}` with `cancel-in-progress` enabled only for main branch pushes. This means if two PRs merge in quick succession, the second run cancels the first since only the latest snapshot matters.
 

.github/workflows/nori-release.yml

@@ -38,7 +38,7 @@ on:
     branches:
       - main
     paths:
-      - "codex-rs/**"
+      - "nori-rs/**"
       - "nori-cli/**"
       - "scripts/**"
       - ".github/workflows/nori-release.yml"
@@ -225,24 +225,24 @@ jobs:
         uses: rui314/setup-mold@v1
 
       - name: cargo check
-        working-directory: codex-rs
+        working-directory: nori-rs
         run: cargo check --profile ci-test --target ${{ env.MUSL_TARGET }} --all-targets
 
       # - name: cargo clippy
-      #   working-directory: codex-rs
+      #   working-directory: nori-rs
       #   run: cargo clippy --target ${{ env.MUSL_TARGET }} --all-features -- -D warnings
 
       # - name: cargo build
-      #   working-directory: codex-rs
+      #   working-directory: nori-rs
       #   run: |
       #     cargo build --profile ci-test --target ${{ env.MUSL_TARGET }} -p nori-cli
       #     cargo build --profile ci-test --target ${{ env.MUSL_TARGET }} -p mock-acp-agent
 
       # - name: cargo test
-      #   working-directory: codex-rs
+      #   working-directory: nori-rs
       #   run: |
       #     cargo test --profile ci-test --target ${{ env.MUSL_TARGET }} --package tui-pty-e2e
-      #     cargo test --profile ci-test --target ${{ env.MUSL_TARGET }} --package codex-acp
+      #     cargo test --profile ci-test --target ${{ env.MUSL_TARGET }} --package nori-acp
       #     cargo test --profile ci-test --target ${{ env.MUSL_TARGET }} --package nori-tui
       #     cargo test --profile ci-test --target ${{ env.MUSL_TARGET }} --package nori-cli
       #     cargo test --profile ci-test --target ${{ env.MUSL_TARGET }} --package codex-protocol
@@ -352,15 +352,15 @@ jobs:
 
       - name: Set version in Cargo.toml
         if: ${{ needs.validate.outputs.publish_next == 'true' }}
-        working-directory: codex-rs
+        working-directory: nori-rs
         run: |
           VERSION="${{ needs.validate.outputs.version }}"
           echo "Injecting version $VERSION into Cargo.toml"
           perl -i -pe 's/^version = "[^"]*"/version = "'"$VERSION"'"/ && ($done=1) unless $done' Cargo.toml
           grep '^version' Cargo.toml | head -1
 
       - name: Build release binaries
-        working-directory: codex-rs
+        working-directory: nori-rs
         run: |
           cargo build --release --target ${{ matrix.target }} -p nori-cli
 
@@ -377,9 +377,9 @@ jobs:
 
           # Copy the main binary
           if [[ "$RUNNER_OS" == "Windows" ]]; then
-            cp codex-rs/target/$TARGET/release/nori.exe artifacts/vendor/$TARGET/nori/nori.exe
+            cp nori-rs/target/$TARGET/release/nori.exe artifacts/vendor/$TARGET/nori/nori.exe
           else
-            cp codex-rs/target/$TARGET/release/nori artifacts/vendor/$TARGET/nori/nori
+            cp nori-rs/target/$TARGET/release/nori artifacts/vendor/$TARGET/nori/nori
             chmod +x artifacts/vendor/$TARGET/nori/nori
           fi
 
@@ -527,7 +527,7 @@ jobs:
         run: |
           VERSION="${{ needs.validate.outputs.version }}"
           TAG_NAME="${{ needs.validate.outputs.tag_name }}"
-          CARGO_TOML_PATH="codex-rs/Cargo.toml"
+          CARGO_TOML_PATH="nori-rs/Cargo.toml"
 
           echo "Creating synthetic commit for version $VERSION"
 

.github/workflows/rust-ci.yml

@@ -11,7 +11,7 @@ jobs:
     timeout-minutes: 30
     defaults:
       run:
-        working-directory: codex-rs
+        working-directory: nori-rs
     env:
       CARGO_INCREMENTAL: "0"
       # Speed up repeated builds across CI runs by caching compiled objects.
@@ -60,8 +60,8 @@ jobs:
         shell: bash
         run: |
           set -euo pipefail
-          echo "hash=${{ hashFiles('codex-rs/Cargo.lock') }}" >> "$GITHUB_OUTPUT"
-          echo "toolchain_hash=${{ hashFiles('codex-rs/rust-toolchain.toml') }}" >> "$GITHUB_OUTPUT"
+          echo "hash=${{ hashFiles('nori-rs/Cargo.lock') }}" >> "$GITHUB_OUTPUT"
+          echo "toolchain_hash=${{ hashFiles('nori-rs/rust-toolchain.toml') }}" >> "$GITHUB_OUTPUT"
 
       # Cache cargo home directory (registry, git deps, etc.)
       - name: Restore cargo home cache
@@ -129,10 +129,10 @@ jobs:
           cargo build -p nori-cli --profile ci-test --target ${{ matrix.target }}
       - name: cargo test nori
         env:
-          MOCK_ACP_AGENT_BIN: ${{ github.workspace }}/codex-rs/target/mock-acp-out/mock_acp_agent
+          MOCK_ACP_AGENT_BIN: ${{ github.workspace }}/nori-rs/target/mock-acp-out/mock_acp_agent
         run: |
           cargo test --profile ci-test --target ${{ matrix.target }} --package tui-pty-e2e
-          cargo test --profile ci-test --target ${{ matrix.target }} --package codex-acp
+          cargo test --profile ci-test --target ${{ matrix.target }} --package nori-acp
           cargo test --profile ci-test --target ${{ matrix.target }} --package nori-tui
           cargo test --profile ci-test --target ${{ matrix.target }} --package nori-cli
           cargo test --profile ci-test --target ${{ matrix.target }} --package codex-protocol

docs.md

@@ -4,13 +4,13 @@ Path: @/
 
 ### Overview
 
-Nori CLI is a multi-provider terminal-based AI coding assistant built in Rust. It provides a unified interface for interacting with AI agents from Anthropic (Claude Code), OpenAI (Codex), and Google (Gemini). The project uses the Agent Client Protocol (ACP) for subprocess-based agent communication and features a Ratatui-based TUI. The implementation is in Rust (`codex-rs`), with a Node.js launcher for npm distribution (`nori-cli`).
+Nori CLI is a multi-provider terminal-based AI coding assistant built in Rust. It provides a unified interface for interacting with AI agents from Anthropic (Claude Code), OpenAI (Codex), and Google (Gemini). The project uses the Agent Client Protocol (ACP) for subprocess-based agent communication and features a Ratatui-based TUI. The implementation is in Rust (`nori-rs`), with a Node.js launcher for npm distribution (`nori-cli`).
 
 ### How it fits into the larger codebase
 
 This is the root repository containing the Nori CLI project:
 
-- **`codex-rs/`**: Main Rust implementation (Cargo workspace with all core functionality)
+- **`nori-rs/`**: Main Rust implementation (Cargo workspace with all core functionality)
 - **`nori-cli/`**: Node.js launcher for npm distribution (thin wrapper that invokes the Rust binary)
 - **`.github/`**: Build and CI configuration
 - **`.claude/`**: Skills and configuration for Claude-based development
@@ -25,12 +25,12 @@ The project was originally forked from OpenAI Codex CLI and has been adapted to
 ```
 ┌─────────────────────────────────────────────────┐
 │                   nori CLI                      │
-│         (codex-rs/tui - main binary)            │
+│         (nori-rs/tui - main binary)            │
 ├─────────────────────────────────────────────────┤
 │                  nori-tui                       │
 │        Interactive Terminal Interface           │
 ├────────────────────────┬────────────────────────┤
-│     codex-acp (acp/)   │   codex-core (core/)   │
+│     nori-acp (acp/)   │   codex-core (core/)   │
 │  ACP Agent Connection  │  Config, Auth, Tools   │
 │  Subprocess Spawning   │  Sandbox, Utilities    │
 ├────────────────────────┴────────────────────────┤
@@ -49,11 +49,11 @@ The project was originally forked from OpenAI Codex CLI and has been adapted to
 
 | Command           | Description        | Implementation        |
 | ----------------- | ------------------ | --------------------- |
-| `nori`            | Interactive TUI    | `codex-rs/tui`        |
-| `nori exec`       | Headless execution | `codex-rs/exec`       |
-| `nori mcp-server` | MCP tool provider  | `codex-rs/mcp-server` |
-| `nori login`      | Authentication     | `codex-rs/login`      |
-| `nori apply`      | Apply cloud diffs  | `codex-rs/chatgpt`    |
+| `nori`              | Interactive TUI          | `nori-rs/tui`                     |
+| `nori login`        | Authentication           | `nori-rs/cli` + `nori-rs/login`   |
+| `nori logout`       | Clear saved credentials  | `nori-rs/cli` + `nori-rs/login`   |
+| `nori sandbox ...`  | Sandbox command runner   | `nori-rs/cli` + platform sandbox crates |
+| `nori skillsets`    | Skillset management shim | `nori-rs/cli`                     |
 
 **Model Providers (via ACP):**
 
@@ -87,10 +87,10 @@ nori resume <SESSION_ID> # Specific session
 
 **MCP Support:**
 
-Nori acts as both MCP client and server:
+Nori acts as an MCP client:
 
-- **Client**: Connects to MCP servers defined in config
-- **Server**: Exposes Nori tools via `nori mcp-server`
+- Connects to MCP servers defined in config
+- Exposes MCP management through the interactive `/mcp` workflow in the TUI
 
 ### Things to Know
 
@@ -99,7 +99,7 @@ Nori acts as both MCP client and server:
 - The `unstable` feature flag gates experimental ACP features like model switching
 - Cross-platform sandboxing is implemented using Landlock (Linux), Seatbelt (macOS), and restricted tokens (Windows)
 - Snapshot testing with `insta` is used extensively for TUI regression testing
-- The project has two justfiles: a root `@/justfile` implementing the Shared Local Runner Layer spec (standardized `help`, `dev`, `test`, `doctor` targets) and `@/codex-rs/justfile` for Rust-specific workflows. The root justfile wraps `codex-rs` by running `cd codex-rs && cargo ...` for each target. Both coexist -- run `just` from the repo root for the standard targets, or `cd codex-rs && just` for the Rust-native recipes
+- The project has two justfiles: a root `@/justfile` implementing the Shared Local Runner Layer spec (standardized `help`, `dev`, `test`, `doctor` targets) and `@/nori-rs/justfile` for Rust-specific workflows. The root justfile wraps `nori-rs` by running `cd nori-rs && cargo ...` for each target. Both coexist -- run `just` from the repo root for the standard targets, or `cd nori-rs && just` for the Rust-native recipes
 - `pnpm` is used for Node.js workspace management in `@/nori-cli/`
 
 Created and maintained by Nori.

flake.nix

@@ -17,11 +17,11 @@
       packages = forAllSystems (system:
         let
           pkgs = nixpkgs.legacyPackages.${system};
-          codex-rs = pkgs.callPackage ./codex-rs { };
+          nori_rs = pkgs.callPackage ./nori-rs { };
         in
         {
-          codex-rs = codex-rs;
-          default = codex-rs;
+          nori-rs = nori_rs;
+          default = nori_rs;
         }
       );
 
@@ -34,7 +34,7 @@
         {
           default = pkgs.mkShell {
             # Inherit build dependencies from package definition
-            inputsFrom = [ (pkgs.callPackage ./codex-rs { }) ];
+            inputsFrom = [ (pkgs.callPackage ./nori-rs { }) ];
 
             # Additional dev tools (Rust toolchain managed by rustup)
             buildInputs = linkerPkgs ++ [

justfile

@@ -34,7 +34,7 @@ help:
 
 # Run the nori binary (primary dev entrypoint)
 dev *args:
-    cd codex-rs && cargo run --bin nori -- "$@"
+    cd nori-rs && cargo run --bin nori -- "$@"
 
 # Run tests for a given scope (default: workspace)
 test *args:
@@ -44,25 +44,25 @@ test *args:
     shift 2>/dev/null || true
     case "$scope" in
       tui)
-        cd codex-rs && cargo test -p nori-tui "$@"
+        cd nori-rs && cargo test -p nori-tui "$@"
         ;;
       acp)
-        cd codex-rs && cargo test -p codex-acp "$@"
+        cd nori-rs && cargo test -p nori-acp "$@"
         ;;
       core)
-        cd codex-rs && cargo test -p codex-core "$@"
+        cd nori-rs && cargo test -p codex-core "$@"
         ;;
       protocol)
-        cd codex-rs && cargo test -p codex-protocol "$@"
+        cd nori-rs && cargo test -p codex-protocol "$@"
         ;;
       e2e)
-        cd codex-rs && cargo build --bin nori && cargo test -p tui-pty-e2e "$@"
+        cd nori-rs && cargo build --bin nori && cargo test -p tui-pty-e2e "$@"
         ;;
       all)
-        cd codex-rs && cargo test --all-features "$@"
+        cd nori-rs && cargo test --all-features "$@"
         ;;
       *)
-        cd codex-rs && cargo test ${scope:+"$scope"} "$@"
+        cd nori-rs && cargo test ${scope:+"$scope"} "$@"
         ;;
     esac
 
@@ -118,8 +118,8 @@ doctor:
     echo ""
     echo "Toolchain:"
     total=$((total + 1))
-    if [ -f codex-rs/rust-toolchain.toml ]; then
-      expected=$(grep 'channel' codex-rs/rust-toolchain.toml | head -1 | sed 's/.*= *"\(.*\)"/\1/')
+    if [ -f nori-rs/rust-toolchain.toml ]; then
+      expected=$(grep 'channel' nori-rs/rust-toolchain.toml | head -1 | sed 's/.*= *"\(.*\)"/\1/')
       active=$(rustup show active-toolchain 2>/dev/null | awk '{print $1}')
       if echo "$active" | grep -q "$expected"; then
         echo "  ok   rust toolchain ($active)"
@@ -139,24 +139,24 @@ doctor:
       exit 1
     fi
 
-# Forward existing codex-rs targets
+# Forward existing nori-rs targets
 
 # Format code
 fmt:
-    cd codex-rs && cargo fmt -- --config imports_granularity=Item
+    cd nori-rs && cargo fmt -- --config imports_granularity=Item
 
 # Auto-fix clippy lints
 fix *args:
-    cd codex-rs && cargo clippy --fix --all-features --tests --allow-dirty "$@"
+    cd nori-rs && cargo clippy --fix --all-features --tests --allow-dirty "$@"
 
 # Run clippy
 clippy:
-    cd codex-rs && cargo clippy --all-features --tests
+    cd nori-rs && cargo clippy --all-features --tests
 
 # Fetch toolchain and dependencies
 install:
-    cd codex-rs && rustup show active-toolchain && cargo fetch
+    cd nori-rs && rustup show active-toolchain && cargo fetch
 
 # Run tests with cargo-nextest
 nextest:
-    cd codex-rs && cargo nextest run --no-fail-fast
+    cd nori-rs && cargo nextest run --no-fail-fast

nori-releases.md

@@ -14,7 +14,7 @@ Upstream releases are very rapid (multiple releases per week):
 Release Workflow (from rust-release.yml):
 
 1. Manual process: git tag -a rust-vX.Y.Z → git push origin rust-vX.Y.Z
-2. CI validates tag matches codex-rs/Cargo.toml version
+2. CI validates tag matches nori-rs/Cargo.toml version
 3. Builds multi-platform binaries with code signing
 4. Publishes to GitHub Releases and npm
 
@@ -100,7 +100,7 @@ git merge sync/upstream-v0.63.0 --no-ff -m "Sync upstream rust-v0.63.0"
 4. Resolve conflicts, test, push
 
 ```bash
-cd codex-rs && cargo test
+cd nori-rs && cargo test
 cargo insta review  # if snapshot tests need updating
 git push origin main
 ```