chore: remove accidentally committed .gjc session state and ignore .gjc/

.envrc

@@ -1 +0,0 @@
-use flake

.github/workflows/release.yml

@@ -57,7 +57,7 @@ jobs:
           mkdir -p dist
           cp "target/release/${{ matrix.bin }}" "dist/${{ matrix.artifact_name }}"
           chmod +x "dist/${{ matrix.artifact_name }}"
-          (cd dist && (sha256sum "${{ matrix.artifact_name }}" 2>/dev/null || shasum -a 256 "${{ matrix.artifact_name }}") > "${{ matrix.artifact_name }}.sha256")
+          (cd dist && sha256sum "${{ matrix.artifact_name }}" > "${{ matrix.artifact_name }}.sha256")
 
       - name: Upload workflow artifact
         uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02

.github/workflows/rust-ci.yml

@@ -25,8 +25,6 @@ on:
       - tests/test_roadmap_helpers.py
       - docs/**
       - rust/**
-      - flake.nix
-      - .envrc
   pull_request:
     branches:
       - main
@@ -49,8 +47,6 @@ on:
       - tests/test_roadmap_helpers.py
       - docs/**
       - rust/**
-      - flake.nix
-      - .envrc
   workflow_dispatch:
 
 concurrency:

.gitignore

@@ -15,7 +15,3 @@ status-help.txt
 .port_sessions/
 # Local agent session state
 .gjc/
-# Nix build outputs and direnv
-.envrc.local
-result
-result-*

docs/nix-development.md

@@ -1,203 +0,0 @@
-# Nix flake development environment
-
-This repository includes a **`flake.nix`** for reproducible development environments on NixOS and systems with Nix installed.
-
-## Prerequisites
-
-- **Nix** (version 2.4 or later with flakes support enabled)
-- **direnv** (optional, for automatic environment loading via `.envrc`)
-
-To verify Nix is installed and flakes are enabled:
-
-```bash
-nix --version
-nix flake --help
-```
-
-If flakes are not enabled, add this to your `~/.config/nix/nix.conf`:
-
-```
-experimental-features = nix-command flakes
-```
-
-## Quick start
-
-### Enter the development environment
-
-**Option 1: Using `nix flake`** (without direnv)
-
-```bash
-nix flake update              # Update inputs (optional, pins nixpkgs)
-nix develop                    # Enter default dev shell
-nix develop .#full             # Enter full dev shell with extra tools
-exit                           # Leave the shell
-```
-
-**Option 2: Using direnv** (automatic on directory entry)
-
-```bash
-direnv allow                   # Trust the .envrc file (one-time setup)
-cd .                           # Direnv reloads the flake automatically
-```
-
-When you leave the repository directory, the environment is automatically unloaded.
-
-## Development shells
-
-The flake provides two development shells:
-
-### `default` (minimal)
-
-```bash
-nix develop
-```
-
-Includes:
-- Rust (stable, latest)
-- Rust source code (`rust-src`)
-- `cargo-edit` (dependency management helpers)
-- `cargo-expand` (macro expansion tool)
-- `cargo-watch` (file watcher for incremental builds)
-- Build tools: `pkg-config`, `openssl`, `git`, `ca-certificates`
-
-### `full` (with extra tooling)
-
-```bash
-nix develop .#full
-```
-
-Includes everything from `default` plus:
-- `clippy` (linter)
-- `rustfmt` (code formatter)
-- `mold` (fast linker)
-- `lldb` (debugger)
-
-## Building the claw binary
-
-### With the dev environment
-
-```bash
-nix develop
-cd rust
-cargo build -p rusty-claude-cli
-```
-
-### Directly with `nix build`
-
-```bash
-nix build .#claw          # Build the claw binary
-nix build                 # Same as .#claw (default package)
-```
-
-The compiled binary is symlinked to `./result/bin/claw`.
-
-## Running common tasks
-
-Once in the dev shell:
-
-```bash
-# Format code
-cd rust
-cargo fmt
-
-# Run clippy linter
-cargo clippy --workspace --all-targets -- -D warnings
-
-# Run all tests
-cargo test --workspace
-
-# Run tests for a specific crate
-cargo test -p rusty-claude-cli
-
-# Build with optimizations
-cargo build --release -p rusty-claude-cli
-```
-
-## Environment variables
-
-The flake automatically sets:
-
-- `RUSTUP_TOOLCHAIN=stable` — uses stable Rust from nixpkgs
-- Standard Rust build flags are inherited from the environment
-
-For development, the minimal dev shell includes a helpful message on entry:
-
-```
-Claw Code development environment
-Run 'cargo build -p rusty-claude-cli' to build the claw binary
-Run 'cargo test --workspace' to run tests
-Run 'scripts/fmt.sh' to format code
-```
-
-## Troubleshooting
-
-### `command not found: nix`
-
-Nix is not installed. Install it from [nixos.org/download.html](https://nixos.org/download.html).
-
-### `error: experimental Nix feature 'flakes' is disabled`
-
-Enable flakes in your Nix configuration (`~/.config/nix/nix.conf` or `/etc/nix/nix.conf`):
-
-```
-experimental-features = nix-command flakes
-```
-
-### `error: ... does not provide attribute 'claw'`
-
-The flake structure may have changed. Try updating:
-
-```bash
-nix flake update
-nix flake check
-```
-
-### Rebuilds are slow after updating dependencies
-
-Cargo will recompile dependencies if `Cargo.lock` changes. This is expected:
-
-```bash
-nix build --rebuild
-```
-
-### `cache lock file needs to be updated`
-
-The Cargo.lock in `rust/` needs to be committed. Run:
-
-```bash
-cd rust
-cargo generate-lockfile
-git add Cargo.lock
-git commit -m "update: Cargo.lock"
-```
-
-## Integration with other tools
-
-### IDE integration (VS Code, IntelliJ, etc.)
-
-Many IDEs can detect and use Nix environments. Direnv integration is recommended:
-
-1. Install the direnv extension
-2. Enable `direnv` shell integration in your IDE
-3. Run `direnv allow` in the repository
-
-Your IDE will automatically use the correct Rust toolchain and dependencies from the flake.
-
-### CI/CD
-
-For GitHub Actions, consider using [cachix/install-nix-action](https://github.com/cachix/install-nix-action) to set up Nix on the runner:
-
-```yaml
-- uses: cachix/install-nix-action@v18
-  with:
-    nix_path: nixpkgs=channel:nixos-unstable
-    extra_nix_config: "experimental-features = nix-command flakes"
-
-- run: nix develop -c cargo test --workspace
-```
-
-## More information
-
-- [NixOS flakes documentation](https://nixos.wiki/wiki/Flakes)
-- [Direnv documentation](https://direnv.net/)
-- [Rust on Nix](https://github.com/oxalica/rust-overlay)

flake.nix

@@ -1,115 +0,0 @@
-{
-  description = "claw-code: Claude Code CLI agent harness in Rust";
-
-  inputs = {
-    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
-    flake-utils.url = "github:numtide/flake-utils";
-    rust-overlay = {
-      url = "github:oxalica/rust-overlay";
-      inputs.nixpkgs.follows = "nixpkgs";
-    };
-  };
-
-  outputs = { self, nixpkgs, flake-utils, rust-overlay }:
-    flake-utils.lib.eachDefaultSystem (system:
-      let
-        overlays = [ (import rust-overlay) ];
-        pkgs = import nixpkgs {
-          inherit system overlays;
-        };
-
-        # Build inputs needed for Rust and the project
-        buildInputs = with pkgs; [
-          pkg-config
-          openssl
-          ca-certificates
-          git
-        ];
-
-        # Runtime inputs for the dev environment
-        nativeBuildInputs = with pkgs; [
-          (rust-bin.stable.latest.default.override {
-            extensions = [ "rust-src" ];
-            targets = [ ];
-          })
-          cargo-edit
-          cargo-expand
-          cargo-watch
-        ];
-
-        # Derivation to build the claw binary
-        clawBinary = pkgs.rustPlatform.buildRustPackage {
-          pname = "claw";
-          version = (builtins.fromTOML (builtins.readFile ./rust/Cargo.toml)).workspace.package.version;
-
-          src = ./rust;
-
-          # Hash of all the dependencies in Cargo.lock
-          # This needs to be updated when dependencies change
-          # Run: nix flake update
-          cargoLock = {
-            lockFile = ./rust/Cargo.lock;
-          };
-
-          cargoBuildFlags = [ "-p" "rusty-claude-cli" ];
-
-          buildInputs = buildInputs ++ (with pkgs; [
-            openssl
-          ]);
-
-          nativeBuildInputs = with pkgs; [
-            pkg-config
-          ];
-
-          meta = with pkgs.lib; {
-            description = "Claude Code CLI: agent harness with Rust implementation";
-            homepage = "https://github.com/ultraworkers/claw-code";
-            license = licenses.mit;
-            platforms = platforms.unix;
-          };
-        };
-
-      in
-      {
-        # Provide the claw binary as a package
-        packages.claw = clawBinary;
-        packages.default = clawBinary;
-
-        # Development shell for contributors
-        devShells.default = pkgs.mkShell {
-          name = "claw-dev";
-          inherit buildInputs nativeBuildInputs;
-
-          shellHook = ''
-            echo "Claw Code development environment"
-            echo "Run 'cargo build -p rusty-claude-cli' to build the claw binary"
-            echo "Run 'cargo test --workspace' to run tests"
-            echo "Run 'scripts/fmt.sh' to format code"
-          '';
-
-          # Make sure we have the right Rust toolchain
-          RUSTUP_TOOLCHAIN = "stable";
-        };
-
-        # Alternative shell with additional development tools
-        devShells.full = pkgs.mkShell {
-          name = "claw-dev-full";
-          inherit buildInputs nativeBuildInputs;
-
-          nativeBuildInputs = nativeBuildInputs ++ (with pkgs; [
-            clippy
-            rustfmt
-            mold
-            lldb
-          ]);
-
-          shellHook = ''
-            echo "Claw Code full development environment (with extra tools)"
-            echo "Available tools: clippy, rustfmt, mold (linker), lldb (debugger)"
-          '';
-
-          RUSTUP_TOOLCHAIN = "stable";
-        };
-      }
-    );
-}

rust/crates/commands/src/lib.rs

@@ -1131,9 +1131,6 @@ pub enum SlashCommand {
     SecurityReview,
     Keybindings,
     PrivacySettings,
-    Workspace {
-        path: Option<String>,
-    },
     Plan {
         mode: Option<String>,
     },
@@ -1275,7 +1272,6 @@ impl SlashCommand {
             Self::SecurityReview => "/security-review",
             Self::Keybindings => "/keybindings",
             Self::PrivacySettings => "/privacy-settings",
-            Self::Workspace { .. } => "/workspace",
             Self::Plan { .. } => "/plan",
             Self::Review { .. } => "/review",
             Self::Tasks { .. } => "/tasks",
@@ -1409,9 +1405,6 @@ pub fn validate_slash_command_input(
             validate_no_args(command, &args)?;
             SlashCommand::Setup
         }
-        "workspace" | "cwd" => SlashCommand::Workspace {
-            path: optional_single_arg(command, &args, "[path]")?,
-        },
         "login" | "logout" => {
             return Err(command_error(
                 "This auth flow was removed. Set ANTHROPIC_API_KEY or ANTHROPIC_AUTH_TOKEN instead.",
@@ -5349,7 +5342,6 @@ pub fn handle_slash_command(
         | SlashCommand::Cost
         | SlashCommand::Resume { .. }
         | SlashCommand::Config { .. }
-        | SlashCommand::Workspace { .. }
         | SlashCommand::Mcp { .. }
         | SlashCommand::Memory
         | SlashCommand::Init
@@ -6127,24 +6119,6 @@ mod tests {
         assert_eq!(suggest_slash_commands("zzz", 3), Vec::<String>::new());
     }
 
-    #[test]
-    fn parses_workspace_slash_command_and_alias() {
-        let workspace = validate_slash_command_input("/workspace")
-            .expect("workspace should parse")
-            .expect("workspace should be a slash command");
-        assert_eq!(workspace, SlashCommand::Workspace { path: None });
-
-        let cwd = validate_slash_command_input("/cwd src")
-            .expect("cwd alias should parse")
-            .expect("cwd alias should be a slash command");
-        assert_eq!(
-            cwd,
-            SlashCommand::Workspace {
-                path: Some("src".to_string()),
-            }
-        );
-    }
-
     #[test]
     fn compacts_sessions_via_slash_command() {
         let mut session = Session::new();

rust/crates/runtime/src/json.rs

@@ -49,10 +49,10 @@ impl JsonValue {
                     .join(",");
                 format!("[{rendered}]")
             }
-            Self::Object(map) => {
-                let rendered = map
+            Self::Object(entries) => {
+                let rendered = entries
                     .iter()
-                    .map(|(k, v)| format!("{}:{}", render_string(k), v.render()))
+                    .map(|(key, value)| format!("{}:{}", render_string(key), value.render()))
                     .collect::<Vec<_>>()
                     .join(",");
                 format!("{{{rendered}}}")
@@ -60,26 +60,21 @@ impl JsonValue {
         }
     }
 
-    #[must_use]
-    pub fn as_bool(&self) -> Option<bool> {
-        match self {
-            Self::Bool(b) => Some(*b),
-            _ => None,
+    pub fn parse(source: &str) -> Result<Self, JsonError> {
+        let mut parser = Parser::new(source);
+        let value = parser.parse_value()?;
+        parser.skip_whitespace();
+        if parser.is_eof() {
+            Ok(value)
+        } else {
+            Err(JsonError::new("unexpected trailing content"))
         }
     }
 
     #[must_use]
-    pub fn as_i64(&self) -> Option<i64> {
+    pub fn as_object(&self) -> Option<&BTreeMap<String, JsonValue>> {
         match self {
-            Self::Number(n) => Some(*n),
-            _ => None,
-        }
-    }
-
-    #[must_use]
-    pub fn as_str(&self) -> Option<&str> {
-        match self {
-            Self::String(s) => Some(s),
+            Self::Object(value) => Some(value),
             _ => None,
         }
     }
@@ -87,354 +82,273 @@ impl JsonValue {
     #[must_use]
     pub fn as_array(&self) -> Option<&[JsonValue]> {
         match self {
-            Self::Array(a) => Some(a),
+            Self::Array(value) => Some(value),
             _ => None,
         }
     }
 
     #[must_use]
-    pub fn as_object(&self) -> Option<&BTreeMap<String, JsonValue>> {
+    pub fn as_str(&self) -> Option<&str> {
         match self {
-            Self::Object(o) => Some(o),
+            Self::String(value) => Some(value),
             _ => None,
         }
     }
 
-    pub fn parse(input: &str) -> Result<Self, JsonError> {
-        let mut chars = input.trim().chars().peekable();
-        let value = parse_value(&mut chars)?;
-        if chars.peek().is_some() {
-            return Err(JsonError::new("trailing content"));
+    #[must_use]
+    pub fn as_bool(&self) -> Option<bool> {
+        match self {
+            Self::Bool(value) => Some(*value),
+            _ => None,
+        }
+    }
+
+    #[must_use]
+    pub fn as_i64(&self) -> Option<i64> {
+        match self {
+            Self::Number(value) => Some(*value),
+            _ => None,
+        }
+    }
+}
+
+fn render_string(value: &str) -> String {
+    let mut rendered = String::with_capacity(value.len() + 2);
+    rendered.push('"');
+    for ch in value.chars() {
+        match ch {
+            '"' => rendered.push_str("\\\""),
+            '\\' => rendered.push_str("\\\\"),
+            '\n' => rendered.push_str("\\n"),
+            '\r' => rendered.push_str("\\r"),
+            '\t' => rendered.push_str("\\t"),
+            '\u{08}' => rendered.push_str("\\b"),
+            '\u{0C}' => rendered.push_str("\\f"),
+            control if control.is_control() => push_unicode_escape(&mut rendered, control),
+            plain => rendered.push(plain),
+        }
+    }
+    rendered.push('"');
+    rendered
+}
+
+fn push_unicode_escape(rendered: &mut String, control: char) {
+    const HEX: &[u8; 16] = b"0123456789abcdef";
+
+    rendered.push_str("\\u");
+    let value = u32::from(control);
+    for shift in [12_u32, 8, 4, 0] {
+        let nibble = ((value >> shift) & 0xF) as usize;
+        rendered.push(char::from(HEX[nibble]));
+    }
+}
+
+struct Parser<'a> {
+    chars: Vec<char>,
+    index: usize,
+    _source: &'a str,
+}
+
+impl<'a> Parser<'a> {
+    fn new(source: &'a str) -> Self {
+        Self {
+            chars: source.chars().collect(),
+            index: 0,
+            _source: source,
+        }
+    }
+
+    fn parse_value(&mut self) -> Result<JsonValue, JsonError> {
+        self.skip_whitespace();
+        match self.peek() {
+            Some('n') => self.parse_literal("null", JsonValue::Null),
+            Some('t') => self.parse_literal("true", JsonValue::Bool(true)),
+            Some('f') => self.parse_literal("false", JsonValue::Bool(false)),
+            Some('"') => self.parse_string().map(JsonValue::String),
+            Some('[') => self.parse_array(),
+            Some('{') => self.parse_object(),
+            Some('-' | '0'..='9') => self.parse_number().map(JsonValue::Number),
+            Some(other) => Err(JsonError::new(format!("unexpected character: {other}"))),
+            None => Err(JsonError::new("unexpected end of input")),
+        }
+    }
+
+    fn parse_literal(&mut self, expected: &str, value: JsonValue) -> Result<JsonValue, JsonError> {
+        for expected_char in expected.chars() {
+            if self.next() != Some(expected_char) {
+                return Err(JsonError::new(format!(
+                    "invalid literal: expected {expected}"
+                )));
+            }
         }
         Ok(value)
     }
-}
 
-fn parse_value(chars: &mut std::iter::Peekable<std::str::Chars>) -> Result<JsonValue, JsonError> {
-    match chars.peek() {
-        Some('n') => parse_null(chars),
-        Some('t') | Some('f') => parse_bool(chars),
-        Some('"') => parse_string(chars).map(JsonValue::String),
-        Some('[') => parse_array(chars),
-        Some('{') => parse_object(chars),
-        Some('-') | Some('0'..='9') => parse_number(chars),
-        Some(c) => Err(JsonError::new(format!("unexpected char: {c}"))),
-        None => Err(JsonError::new("empty input")),
-    }
-}
-
-fn parse_null(chars: &mut std::iter::Peekable<std::str::Chars>) -> Result<JsonValue, JsonError> {
-    if consume_literal(chars, "null") {
-        Ok(JsonValue::Null)
-    } else {
-        Err(JsonError::new("invalid null"))
-    }
-}
-
-fn parse_bool(chars: &mut std::iter::Peekable<std::str::Chars>) -> Result<JsonValue, JsonError> {
-    if consume_literal(chars, "true") {
-        return Ok(JsonValue::Bool(true));
-    }
-    if consume_literal(chars, "false") {
-        return Ok(JsonValue::Bool(false));
-    }
-    Err(JsonError::new("invalid bool"))
-}
-
-fn parse_string(chars: &mut std::iter::Peekable<std::str::Chars>) -> Result<String, JsonError> {
-    if chars.next() != Some('"') {
-        return Err(JsonError::new("expected opening quote"));
+    fn parse_string(&mut self) -> Result<String, JsonError> {
+        self.expect('"')?;
+        let mut value = String::new();
+        while let Some(ch) = self.next() {
+            match ch {
+                '"' => return Ok(value),
+                '\\' => value.push(self.parse_escape()?),
+                plain => value.push(plain),
+            }
+        }
+        Err(JsonError::new("unterminated string"))
     }
 
-    let mut result = String::new();
-    loop {
-        match chars.next() {
-            None => return Err(JsonError::new("unterminated string")),
-            Some('"') => return Ok(result),
-            Some('\\') => match chars.next() {
-                Some('"') => result.push('"'),
-                Some('\\') => result.push('\\'),
-                Some('/') => result.push('/'),
-                Some('b') => result.push('\u{08}'),
-                Some('f') => result.push('\u{0C}'),
-                Some('n') => result.push('\n'),
-                Some('r') => result.push('\r'),
-                Some('t') => result.push('\t'),
-                Some('u') => {
-                    let mut hex = String::new();
-                    for _ in 0..4 {
-                        match chars.next() {
-                            Some(c @ '0'..='9') | Some(c @ 'a'..='f') | Some(c @ 'A'..='F') => {
-                                hex.push(c)
-                            }
-                            _ => return Err(JsonError::new("invalid unicode escape")),
-                        }
-                    }
-                    let code = u32::from_str_radix(&hex, 16)
-                        .map_err(|_| JsonError::new("invalid hex code"))?;
-                    if (0xD800..=0xDFFF).contains(&code) {
-                        return Err(JsonError::new("surrogate not allowed"));
-                    }
-                    result.push(
-                        char::from_u32(code).ok_or_else(|| JsonError::new("invalid codepoint"))?,
-                    );
-                }
-                _ => return Err(JsonError::new("invalid escape")),
-            },
-            Some(c) => result.push(c),
+    fn parse_escape(&mut self) -> Result<char, JsonError> {
+        match self.next() {
+            Some('"') => Ok('"'),
+            Some('\\') => Ok('\\'),
+            Some('/') => Ok('/'),
+            Some('b') => Ok('\u{08}'),
+            Some('f') => Ok('\u{0C}'),
+            Some('n') => Ok('\n'),
+            Some('r') => Ok('\r'),
+            Some('t') => Ok('\t'),
+            Some('u') => self.parse_unicode_escape(),
+            Some(other) => Err(JsonError::new(format!("invalid escape sequence: {other}"))),
+            None => Err(JsonError::new("unexpected end of input in escape sequence")),
         }
     }
-}
 
-fn parse_number(chars: &mut std::iter::Peekable<std::str::Chars>) -> Result<JsonValue, JsonError> {
-    let mut num_str = String::new();
-
-    if chars.peek() == Some(&'-') {
-        num_str.push(chars.next().unwrap());
+    fn parse_unicode_escape(&mut self) -> Result<char, JsonError> {
+        let mut value = 0_u32;
+        for _ in 0..4 {
+            let Some(ch) = self.next() else {
+                return Err(JsonError::new("unexpected end of input in unicode escape"));
+            };
+            value = (value << 4)
+                | ch.to_digit(16)
+                    .ok_or_else(|| JsonError::new("invalid unicode escape"))?;
+        }
+        char::from_u32(value).ok_or_else(|| JsonError::new("invalid unicode scalar value"))
     }
 
-    while let Some(&c) = chars.peek() {
-        if c.is_ascii_digit() {
-            num_str.push(chars.next().unwrap());
+    fn parse_array(&mut self) -> Result<JsonValue, JsonError> {
+        self.expect('[')?;
+        let mut values = Vec::new();
+        loop {
+            self.skip_whitespace();
+            if self.try_consume(']') {
+                break;
+            }
+            values.push(self.parse_value()?);
+            self.skip_whitespace();
+            if self.try_consume(']') {
+                break;
+            }
+            self.expect(',')?;
+        }
+        Ok(JsonValue::Array(values))
+    }
+
+    fn parse_object(&mut self) -> Result<JsonValue, JsonError> {
+        self.expect('{')?;
+        let mut entries = BTreeMap::new();
+        loop {
+            self.skip_whitespace();
+            if self.try_consume('}') {
+                break;
+            }
+            let key = self.parse_string()?;
+            self.skip_whitespace();
+            self.expect(':')?;
+            let value = self.parse_value()?;
+            entries.insert(key, value);
+            self.skip_whitespace();
+            if self.try_consume('}') {
+                break;
+            }
+            self.expect(',')?;
+        }
+        Ok(JsonValue::Object(entries))
+    }
+
+    fn parse_number(&mut self) -> Result<i64, JsonError> {
+        let mut value = String::new();
+        if self.try_consume('-') {
+            value.push('-');
+        }
+
+        while let Some(ch @ '0'..='9') = self.peek() {
+            value.push(ch);
+            self.index += 1;
+        }
+
+        if value.is_empty() || value == "-" {
+            return Err(JsonError::new("invalid number"));
+        }
+
+        value
+            .parse::<i64>()
+            .map_err(|_| JsonError::new("number out of range"))
+    }
+
+    fn expect(&mut self, expected: char) -> Result<(), JsonError> {
+        match self.next() {
+            Some(actual) if actual == expected => Ok(()),
+            Some(actual) => Err(JsonError::new(format!(
+                "expected '{expected}', found '{actual}'"
+            ))),
+            None => Err(JsonError::new(format!(
+                "expected '{expected}', found end of input"
+            ))),
+        }
+    }
+
+    fn try_consume(&mut self, expected: char) -> bool {
+        if self.peek() == Some(expected) {
+            self.index += 1;
+            true
         } else {
-            break;
+            false
         }
     }
 
-    if num_str.is_empty() || num_str == "-" {
-        return Err(JsonError::new("invalid number"));
-    }
-
-    num_str
-        .parse::<i64>()
-        .map(JsonValue::Number)
-        .map_err(|_| JsonError::new("number out of range"))
-}
-
-fn parse_array(chars: &mut std::iter::Peekable<std::str::Chars>) -> Result<JsonValue, JsonError> {
-    if chars.next() != Some('[') {
-        return Err(JsonError::new("expected ["));
-    }
-
-    let mut values = Vec::new();
-
-    skip_whitespace(chars);
-    if chars.peek() == Some(&']') {
-        chars.next();
-        return Ok(JsonValue::Array(values));
-    }
-
-    loop {
-        skip_whitespace(chars);
-        values.push(parse_value(chars)?);
-        skip_whitespace(chars);
-
-        match chars.peek() {
-            Some(',') => {
-                chars.next();
-            }
-            Some(']') => {
-                chars.next();
-                return Ok(JsonValue::Array(values));
-            }
-            _ => return Err(JsonError::new("expected , or ]")),
+    fn skip_whitespace(&mut self) {
+        while matches!(self.peek(), Some(' ' | '\n' | '\r' | '\t')) {
+            self.index += 1;
         }
     }
-}
 
-fn parse_object(chars: &mut std::iter::Peekable<std::str::Chars>) -> Result<JsonValue, JsonError> {
-    if chars.next() != Some('{') {
-        return Err(JsonError::new("expected {"));
+    fn peek(&self) -> Option<char> {
+        self.chars.get(self.index).copied()
     }
 
-    let mut map = BTreeMap::new();
-
-    skip_whitespace(chars);
-    if chars.peek() == Some(&'}') {
-        chars.next();
-        return Ok(JsonValue::Object(map));
+    fn next(&mut self) -> Option<char> {
+        let ch = self.peek()?;
+        self.index += 1;
+        Some(ch)
     }
 
-    loop {
-        skip_whitespace(chars);
-
-        if chars.peek() != Some(&'"') {
-            return Err(JsonError::new("expected key string"));
-        }
-        let key = parse_string(chars)?;
-
-        skip_whitespace(chars);
-        if chars.next() != Some(':') {
-            return Err(JsonError::new("expected :"));
-        }
-
-        skip_whitespace(chars);
-        let value = parse_value(chars)?;
-        map.insert(key, value);
-
-        skip_whitespace(chars);
-        match chars.peek() {
-            Some(',') => {
-                chars.next();
-            }
-            Some('}') => {
-                chars.next();
-                return Ok(JsonValue::Object(map));
-            }
-            _ => return Err(JsonError::new("expected , or }")),
-        }
+    fn is_eof(&self) -> bool {
+        self.index >= self.chars.len()
     }
 }
 
-fn consume_literal(chars: &mut std::iter::Peekable<std::str::Chars>, literal: &str) -> bool {
-    let remaining: String = chars.clone().collect();
-    if remaining.starts_with(literal) {
-        for _ in literal.chars() {
-            chars.next();
-        }
-        true
-    } else {
-        false
-    }
-}
-
-fn skip_whitespace(chars: &mut std::iter::Peekable<std::str::Chars>) {
-    while let Some(&c) = chars.peek() {
-        if c.is_whitespace() {
-            chars.next();
-        } else {
-            break;
-        }
-    }
-}
-
-fn render_string(s: &str) -> String {
-    let mut result = String::from('"');
-    for c in s.chars() {
-        match c {
-            '"' => result.push_str("\\\""),
-            '\\' => result.push_str("\\\\"),
-            '\n' => result.push_str("\\n"),
-            '\r' => result.push_str("\\r"),
-            '\t' => result.push_str("\\t"),
-            '\u{08}' => result.push_str("\\b"),
-            '\u{0C}' => result.push_str("\\f"),
-            c if c.is_control() => {
-                let code = c as u32;
-                result.push_str(&format!("\\u{code:04x}"));
-            }
-            c => result.push(c),
-        }
-    }
-    result.push('"');
-    result
-}
-
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use super::{render_string, JsonValue};
+    use std::collections::BTreeMap;
 
     #[test]
-    fn renders_primitive_values() {
-        assert_eq!(JsonValue::Null.render(), "null");
-        assert_eq!(JsonValue::Bool(true).render(), "true");
-        assert_eq!(JsonValue::Bool(false).render(), "false");
-        assert_eq!(JsonValue::Number(42).render(), "42");
-        assert_eq!(JsonValue::Number(-7).render(), "-7");
-        assert_eq!(JsonValue::String("hi".to_string()).render(), "\"hi\"");
-    }
-
-    #[test]
-    fn renders_arrays_and_objects_with_sorted_keys() {
-        assert_eq!(JsonValue::Array(Vec::new()).render(), "[]");
-        assert_eq!(
-            JsonValue::Array(vec![JsonValue::Number(1), JsonValue::Number(2)]).render(),
-            "[1,2]"
-        );
-        assert_eq!(JsonValue::Object(BTreeMap::new()).render(), "{}");
-
+    fn renders_and_parses_json_values() {
         let mut object = BTreeMap::new();
-        object.insert("b".to_string(), JsonValue::Bool(false));
-        object.insert("a".to_string(), JsonValue::Number(1));
-        // A BTreeMap iterates keys in sorted order, so object rendering is
-        // deterministic regardless of insertion order.
-        assert_eq!(JsonValue::Object(object).render(), "{\"a\":1,\"b\":false}");
-    }
-
-    #[test]
-    fn render_string_escapes_quotes_backslashes_and_other_controls() {
-        // Backslash and double-quote are backslash-escaped.
-        assert_eq!(render_string("\"\\"), "\"\\\"\\\\\"");
-        // Carriage return has a dedicated short escape.
-        assert_eq!(render_string("\r"), "\"\\r\"");
-        // Other control characters fall back to the \uXXXX form (U+0001 here).
-        assert_eq!(render_string("\u{1}"), "\"\\u0001\"");
-    }
-
-    #[test]
-    fn parses_primitive_values() {
-        assert_eq!(
-            JsonValue::parse("null").expect("null parses"),
-            JsonValue::Null
-        );
-        assert_eq!(
-            JsonValue::parse("true").expect("true parses"),
-            JsonValue::Bool(true)
-        );
-        assert_eq!(
-            JsonValue::parse("false").expect("false parses"),
-            JsonValue::Bool(false)
-        );
-        assert_eq!(
-            JsonValue::parse("\"hello\"").expect("string parses"),
-            JsonValue::String("hello".to_string())
-        );
-    }
-
-    #[test]
-    fn parses_signed_integers_and_ignores_surrounding_whitespace() {
-        assert_eq!(
-            JsonValue::parse("-42").expect("negative parses").as_i64(),
-            Some(-42)
-        );
-        assert_eq!(
-            JsonValue::parse("  123  ").expect("padded parses").as_i64(),
-            Some(123)
-        );
-    }
-
-    #[test]
-    fn parses_nested_arrays_and_objects() {
-        let value =
-            JsonValue::parse("{\"nums\": [1, 2], \"flag\": true}").expect("nested json parses");
-        let object = value.as_object().expect("top level is an object");
-
-        assert_eq!(object.len(), 2);
-
-        let nums = object
-            .get("nums")
-            .and_then(JsonValue::as_array)
-            .expect("nums is an array");
-        assert_eq!(nums.len(), 2);
-        assert_eq!(nums[0].as_i64(), Some(1));
-
-        assert_eq!(object.get("flag").and_then(JsonValue::as_bool), Some(true));
-    }
-
-    #[test]
-    fn round_trips_rendered_values_through_the_parser() {
-        let mut object = BTreeMap::new();
-        object.insert("name".to_string(), JsonValue::String("clawi".to_string()));
-        object.insert("count".to_string(), JsonValue::Number(-3));
+        object.insert("flag".to_string(), JsonValue::Bool(true));
         object.insert(
-            "tags".to_string(),
-            JsonValue::Array(vec![JsonValue::Bool(true), JsonValue::Null]),
+            "items".to_string(),
+            JsonValue::Array(vec![
+                JsonValue::Number(4),
+                JsonValue::String("ok".to_string()),
+            ]),
         );
-        let original = JsonValue::Object(object);
 
-        let reparsed = JsonValue::parse(&original.render()).expect("rendered json should re-parse");
+        let rendered = JsonValue::Object(object).render();
+        let parsed = JsonValue::parse(&rendered).expect("json should parse");
 
-        assert_eq!(reparsed, original);
+        assert_eq!(parsed.as_object().expect("object").len(), 2);
     }
 
     #[test]
@@ -519,7 +433,6 @@ mod tests {
         object.insert("a\nb".to_string(), JsonValue::String("c\td".to_string()));
         let original = JsonValue::Object(object);
         let reparsed = JsonValue::parse(&original.render()).expect("escaped key re-parses");
-
         assert_eq!(reparsed, original);
     }
 
@@ -558,37 +471,4 @@ mod tests {
             "i64::MIN - 1"
         );
     }
-
-    #[test]
-    fn parse_rejects_malformed_input() {
-        assert!(JsonValue::parse("").is_err(), "empty input");
-        assert!(JsonValue::parse("nul").is_err(), "truncated literal");
-        assert!(JsonValue::parse("true false").is_err(), "trailing content");
-        assert!(
-            JsonValue::parse("\"unterminated").is_err(),
-            "unterminated string"
-        );
-        assert!(JsonValue::parse("[1, 2").is_err(), "unterminated array");
-    }
-
-    #[test]
-    fn parse_rejects_integers_outside_the_i64_range() {
-        // Far beyond i64::MAX (~9.2e18): the parser must reject rather than
-        // silently truncate the value.
-        assert!(JsonValue::parse("9999999999999999999999999").is_err());
-    }
-
-    #[test]
-    fn accessors_return_none_for_mismatched_variants() {
-        assert_eq!(JsonValue::Null.as_bool(), None);
-        assert_eq!(JsonValue::Bool(true).as_i64(), None);
-        assert!(JsonValue::Number(1).as_str().is_none());
-        assert!(JsonValue::Number(1).as_array().is_none());
-        assert!(JsonValue::String("x".to_string()).as_object().is_none());
-    }
-
-    #[test]
-    fn json_error_displays_its_message() {
-        assert_eq!(JsonError::new("boom").to_string(), "boom");
-    }
 }

rust/crates/rusty-claude-cli/src/main.rs

@@ -6715,49 +6715,6 @@ fn run_resume_command(
             message: Some(render_memory_report()?),
             json: Some(render_memory_json()?),
         }),
-        SlashCommand::Workspace { path } => {
-            let cwd_before = env::current_dir()?;
-            let workspace_root = session
-                .workspace_root()
-                .map(Path::to_path_buf)
-                .unwrap_or_else(|| cwd_before.clone());
-            let workspace_root = canonicalize_or_clone(&workspace_root);
-            let changed = if let Some(path) = path.as_deref() {
-                let requested_path = Path::new(path);
-                let resolved_path = if requested_path.is_absolute() {
-                    requested_path.to_path_buf()
-                } else {
-                    cwd_before.join(requested_path)
-                };
-                let resolved_path = canonicalize_or_clone(&resolved_path);
-                if !resolved_path.starts_with(&workspace_root) {
-                    return Err(format!(
-                        "workspace_change_outside_root: `{}` is outside the current workspace root `{}`.\nUse `claw --cwd {}` to start a new session there.",
-                        resolved_path.display(),
-                        workspace_root.display(),
-                        resolved_path.display(),
-                    )
-                    .into());
-                }
-                env::set_current_dir(&resolved_path)?;
-                true
-            } else {
-                false
-            };
-            let cwd_after = env::current_dir()?;
-            let message =
-                render_workspace_report(&cwd_after, &workspace_root, &session.session_id, changed);
-            Ok(ResumeCommandOutcome {
-                session: session.clone(),
-                message: Some(message),
-                json: Some(workspace_report_json(
-                    &cwd_after,
-                    &workspace_root,
-                    &session.session_id,
-                    changed,
-                )),
-            })
-        }
         SlashCommand::Init => {
             // #142: run the init once, then render both text + structured JSON
             // from the same InitReport so both surfaces stay in sync.
@@ -8259,7 +8216,6 @@ impl LiveCli {
                 Self::print_config(section.as_deref())?;
                 false
             }
-            SlashCommand::Workspace { path } => self.handle_workspace_command(path.as_deref())?,
             SlashCommand::Mcp { action, target } => {
                 let args = match (action.as_deref(), target.as_deref()) {
                     (None, None) => None,
@@ -8418,51 +8374,6 @@ impl LiveCli {
         );
     }
 
-    fn handle_workspace_command(
-        &mut self,
-        target: Option<&str>,
-    ) -> Result<bool, Box<dyn std::error::Error>> {
-        let current_dir = env::current_dir()?;
-        let workspace_root = self
-            .runtime
-            .session()
-            .workspace_root()
-            .map(Path::to_path_buf)
-            .unwrap_or_else(|| current_dir.clone());
-        let workspace_root = canonicalize_or_clone(&workspace_root);
-
-        if let Some(target) = target {
-            let requested_path = Path::new(target);
-            let resolved_path = if requested_path.is_absolute() {
-                requested_path.to_path_buf()
-            } else {
-                current_dir.join(requested_path)
-            };
-            let resolved_path = canonicalize_or_clone(&resolved_path);
-            if !resolved_path.starts_with(&workspace_root) {
-                return Err(format!(
-                    "workspace_change_outside_root: `{}` is outside the current workspace root `{}`.\nUse `claw --cwd {}` to start a new session there.",
-                    resolved_path.display(),
-                    workspace_root.display(),
-                    resolved_path.display(),
-                )
-                .into());
-            }
-            env::set_current_dir(&resolved_path)?;
-        }
-
-        println!(
-            "{}",
-            render_workspace_report(
-                &env::current_dir()?,
-                &workspace_root,
-                &self.session.id,
-                target.is_some(),
-            )
-        );
-        Ok(target.is_some())
-    }
-
     fn record_prompt_history(&mut self, prompt: &str) {
         let timestamp_ms = std::time::SystemTime::now()
             .duration_since(UNIX_EPOCH)
@@ -9303,41 +9214,6 @@ fn new_cli_session() -> Result<Session, Box<dyn std::error::Error>> {
     Ok(Session::new().with_workspace_root(env::current_dir()?))
 }
 
-fn canonicalize_or_clone(path: &Path) -> PathBuf {
-    fs::canonicalize(path).unwrap_or_else(|_| path.to_path_buf())
-}
-
-fn render_workspace_report(
-    cwd: &Path,
-    workspace_root: &Path,
-    session_id: &str,
-    changed: bool,
-) -> String {
-    let action = if changed { "change" } else { "show" };
-    format!(
-        "Workspace\n  Action           {action}\n  Session          {session_id}\n  Workspace root   {}\n  Current directory {}",
-        workspace_root.display(),
-        cwd.display(),
-    )
-}
-
-fn workspace_report_json(
-    cwd: &Path,
-    workspace_root: &Path,
-    session_id: &str,
-    changed: bool,
-) -> Value {
-    serde_json::json!({
-        "kind": "workspace",
-        "action": if changed { "change" } else { "show" },
-        "status": "ok",
-        "session_id": session_id,
-        "workspace_root": workspace_root.display().to_string(),
-        "current_directory": cwd.display().to_string(),
-        "changed": changed,
-    })
-}
-
 fn create_managed_session_handle(
     session_id: &str,
 ) -> Result<SessionHandle, Box<dyn std::error::Error>> {

rust/crates/rusty-claude-cli/tests/output_format_contract.rs

@@ -441,9 +441,6 @@ fn status_and_sandbox_emit_json_when_requested() {
 
 // #831: direct resume-safe slash commands should use the same local CliAction
 // JSON surfaces as their bare subcommands, not interactive_only guidance.
-// Note: /sandbox status depends on kernel support for user namespaces.
-// On systems with working user namespaces the status is "ok".
-// On systems without user namespaces the status is "warn" (#731).
 #[test]
 fn direct_resume_safe_slash_commands_route_to_local_json_actions_831() {
     let root = unique_temp_dir("direct-resume-safe-slash-831");
@@ -454,11 +451,11 @@ fn direct_resume_safe_slash_commands_route_to_local_json_actions_831() {
         .output()
         .expect("git init should launch");
 
-    for (command, expected_kind, expected_statuses) in [
-        ("/version", "version", &["ok"][..]),
-        ("/sandbox", "sandbox", &["ok", "warn"][..]),
-        ("/diff", "diff", &["ok"][..]),
-        ("/status", "status", &["ok"][..]),
+    for (command, expected_kind, expected_status) in [
+        ("/version", "version", "ok"),
+        ("/sandbox", "sandbox", "warn"),
+        ("/diff", "diff", "ok"),
+        ("/status", "status", "ok"),
     ] {
         let output = run_claw(&root, &["--output-format", "json", command], &[]);
         assert!(
@@ -473,9 +470,9 @@ fn direct_resume_safe_slash_commands_route_to_local_json_actions_831() {
             .unwrap_or_else(|_| panic!("{command} must emit JSON (#831), got: {stdout:?}"));
 
         assert_eq!(parsed["kind"], expected_kind, "{command} kind: {parsed}");
-        assert!(
-            expected_statuses.contains(&parsed["status"].as_str().unwrap_or("")),
-            "{command} status must be one of {expected_statuses:?}: {parsed}"
+        assert_eq!(
+            parsed["status"], expected_status,
+            "{command} status: {parsed}"
         );
         assert_ne!(
             parsed["error_kind"], "interactive_only",