feat(runtime): implement per-session settings override & schema validation

Implement issue #3325 (Slice 3.1) Config: Settings Override & Schema Validation Additions: - Setting schema registry with support for multiple value types - SessionSettings struct with three-level hierarchy (global, session, request) - SettingApplicator for merging and applying settings - ConfigHotreloadMonitor for filesystem monitoring - 36 comprehensive tests covering: - Schema validation with allowed values - Override hierarchy (request > session > global > default) - Permission mode overrides per-session - Temperature/token overrides work correctly - Dynamic setting application mid-session - Settings propagation to all tools - Config hotreload detection - Default values and type validation - Non-overridable settings Size: ~750 LOC with tests References: - Issue #3325: [Slice 3.1] Config: Settings Override & Schema Validation - Crate: runtime (enhance existing config.rs)
Merge pull request #3339 from ultraworkers/lane/gjc-s32-r4-commands-impl
2026-10-16 00:00:16 +08:00 · 2026-10-13 01:05:42 +00:00 · 2026-10-13 09:24:24 +09:00 · 2026-10-13 00:19:41 +00:00 · 2026-10-13 09:18:54 +09:00 · 2026-10-13 09:17:32 +09:00
22 changed files with 3937 additions and 271 deletions
@@ -5,6 +5,43 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

+## [0.1.4] - 2026-10-13
+
+### Added
+
+- GJC-compatible line range selectors for read_file tool (`:50-200`, `:50+150` syntax)
+- GJC-compatible `:conflicts` selector for git merge conflict detection
+- SDK wire transport with WebSocket support
+- Nix flake development environment
+- Persistent provider configuration loading
+- Pagination support for large read_file results
+- Comprehensive GJC compatibility documentation and analysis
+
+### Fixed
+
+- Windows path containment checks for security boundary enforcement
+- Git bash detection on Windows with proper probe caching
+- Unresolvable path denial to prevent escape attempts
+- Auto-compaction context window measurement
+- Tool result preservation on failed turns
+- Model stall recovery without tool calls
+- Streaming markdown formatting with preserved block separators
+- Local model validation bypass generalization beyond Ollama
+- Release artifact checksums on macOS and Linux
+- Duplicate assistant text rendering
+- Workspace slash command wire-up
+
+### Changed
+
+- Enhanced path scope validation for multiple Windows path spellings
+- Improved error handling and configuration defaults
+- Upgraded GitHub Actions to immutable commit SHAs for CI security
+
+### Known Limitations
+
+- ACP / Zed integration is not yet implemented (status stub available via `claw acp`)
+- Python porting workspace is for reference only, not used in production
+
 ## [0.1.3] - 2026-10-13

 This is the first public binary release of Claw Code.
@@ -0,0 +1,338 @@
+# GJC Tool Semantics Alignment: Phase 1 (read/edit/search/find)
+
+**Status**: Implementation plan  
+**Issue**: #3323  
+**Scope**: Slice 2.1 - Tool catalog semantic parity for read/edit/search/find  
+**Target**: Ship in batches with focused PRs
+
+---
+
+## 1. EXECUTIVE SUMMARY
+
+This document details the semantic gaps between claw-code's current tool implementations and GJC's (gajae-code) reference implementations for the highest-value tools: **read**, **edit**, **search**, and **find**.
+
+### Key Gaps
+
+| Tool | Current (claw-code) | Target (GJC) | Gap | Complexity |
+|------|-----|--------|-----|------------|
+| **read** | offset/limit pagination | Line selectors (`:L-L+N`), raw mode, truncation footers | High | Medium |
+| **write** | Simple file replacement | Full replacement semantics (matching GJC) | Low | Low |
+| **edit** | String replacement (old→new) | String replacement with rich patch output | Low | Low |
+| **find** (glob) | Pattern expansion only | Recursive glob with filtering | Low | Low |
+| **search** (grep) | Regex search with context | Regex with context + advanced filtering | Low | Low |
+
+---
+
+## 2. GJC TOOL SEMANTICS REFERENCE
+
+### 2.1 READ Tool
+
+**Source**: `gajae-code/packages/coding-agent/src/tools/read.ts` (3,500+ LOC)
+
+#### Input Schema
+```typescript
+{
+  path: string;           // File path (relative or absolute)
+  offset?: number;        // Line offset (for pagination)
+  limit?: number;         // Lines to read (for pagination)
+  // GJC extensions (missing in claw-code):
+  selector?: string;      // Line range syntax:
+                          // ":50" = line 50 onward
+                          // ":50-200" = lines 50-200 inclusive
+                          // ":50+150" = 150 lines starting at line 50
+                          // ":raw" = full file verbatim
+                          // ":conflicts" = git merge conflicts only
+  truncationDirection?: "head" | "tail" | "both";  // Which end to keep
+  maxSummaryBytes?: number;  // Summary budget (default 50KB)
+  maxSummaryLines?: number;  // Summary budget (default 20K lines)
+}
+```
+
+#### Output Structure
+```json
+{
+  "file": {
+    "path": "src/main.rs",
+    "content": "...",
+    "totalLines": 500,
+    "totalBytes": 12345,
+    "truncatedBy": "lines" | "bytes" | "middle" | null,
+    "displayMode": "summarized" | "raw" | "receipt"
+  },
+  "truncationFooter": "[Showing lines 1-50 of 500; re-read ...]"
+}
+```
+
+#### Key Behaviors
+
+1. **Line Range Selectors** (`:selector` syntax)
+   - `:50` = start at line 50
+   - `:50-200` = lines 50-200 inclusive
+   - `:50+150` = 150 lines starting at 50
+   - `:50+1` = exactly one line
+   - `:5-16,960-973` = multiple ranges
+   - `:raw` = full verbatim
+   - `:conflicts` = git merge conflicts
+
+2. **Truncation Modes**
+   - Default: 50KB bytes limit, 20K lines limit
+   - Direction: `head` (keep start), `tail` (keep end), `both` (keep both ends)
+   - Footer includes recovery hint (e.g., "`re-read path:1-9999` for verbatim")
+
+3. **Structural Summarization**
+   - Code: collapse function bodies to `..` or `…` (merged brace pairs)
+   - Prose: preserve full lines, truncate at word boundaries
+   - Special files: documents (PDF, DOCX, XLSX) converted via markit
+
+4. **Archive Support**
+   - `.tar`, `.tar.gz`, `.tgz`, `.zip`: member read with `archive.ext:path/inside`
+   - SQLite: `.sqlite:table` or `.sqlite:table:key` queries
+   - Line ranges apply to archive members
+
+5. **Output Formatting**
+   - Anchored output: Line prefixes with source line numbers and hash anchors
+   - Optional hash lines: Marks structural boundaries (`# pragma`, function start, etc.)
+   - Prose column cap: Long lines wrapped/truncated at column limit
+
+### 2.2 EDIT Tool
+
+**Source**: `gajae-code/packages/coding-agent/src/tools/edit.ts`
+
+#### Input Schema
+```typescript
+{
+  path: string;           // File to edit
+  old_text: string;       // Text to replace (required for edit)
+  new_text: string;       // Replacement text
+  all?: boolean;          // Replace all occurrences (default: first only)
+}
+```
+
+#### Output Structure
+```json
+{
+  "file": {
+    "path": "src/main.rs",
+    "editCount": 1,
+    "beforeSize": 12345,
+    "afterSize": 12400
+  },
+  "patch": [
+    {
+      "type": "replace",
+      "lineStart": 50,
+      "lineEnd": 55,
+      "before": "old content",
+      "after": "new content",
+      "context": {"before": 3, "after": 3}
+    }
+  ]
+}
+```
+
+#### Key Behaviors
+
+1. **Exact Match Required**: `old_text` must match exactly (no fuzzy matching)
+2. **Smallest Replacement**: Use smallest unique old_text that identifies the change
+3. **All-or-Nothing**: Either all occurrences replaced or none (no partial)
+4. **Patch Metadata**: Line numbers, context, before/after preserved
+
+### 2.3 SEARCH Tool
+
+**Source**: `gajae-code/packages/coding-agent/src/tools/search.ts`
+
+#### Input Schema
+```typescript
+{
+  pattern: string;        // Regex pattern
+  paths?: string[];       // Files/dirs to search
+  context?: number;       // Context lines before/after (default: 2)
+  i?: boolean;            // Case-insensitive
+  glob_exclude?: string[];  // Patterns to skip
+  file_type?: string;     // Filter by extension
+  limit?: number;         // Max results
+  truncation?: "head" | "tail" | "both";
+}
+```
+
+#### Output Structure
+```json
+{
+  "matches": [
+    {
+      "file": "src/main.rs",
+      "lineNumber": 42,
+      "line": "fn process() {",
+      "before": ["// Process data", ""],
+      "after": ["  // Implementation", ""]
+    }
+  ],
+  "summary": "Found 5 matches in 3 files"
+}
+```
+
+### 2.4 FIND Tool
+
+**Source**: `gajae-code/packages/coding-agent/src/tools/find.ts`
+
+#### Input Schema
+```typescript
+{
+  paths: string[];        // Glob patterns
+  timeout?: number;       // Timeout in seconds (default: 5)
+  gitignore?: boolean;    // Respect .gitignore (default: true)
+  hidden?: boolean;       // Include hidden files (default: true)
+  limit?: number;         // Max results (default: 1000)
+}
+```
+
+#### Output Structure
+```json
+{
+  "files": [
+    {
+      "path": "src/main.rs",
+      "modified": "2026-10-13T12:34:56Z",
+      "size": 12345
+    }
+  ],
+  "summary": "Found 42 files matching pattern",
+  "truncated": false
+}
+```
+
+---
+
+## 3. CURRENT CLAW-CODE IMPLEMENTATION GAPS
+
+### 3.1 READ Tool Gaps
+
+**File**: `rust/crates/runtime/src/file_ops.rs:713`
+
+**Current**:
+```rust
+pub fn read_file_in_workspace(
+    path: &str,
+    offset: Option<usize>,     // Line offset only
+    limit: Option<usize>,      // Lines only
+    workspace_root: &Path,
+) -> io::Result<ReadFileOutput>
+```
+
+**Missing**:
+- ✗ Line range selectors (`:L-L+N` syntax)
+- ✗ Raw mode (`:raw`)
+- ✓ Git merge conflict extraction (`:conflicts`)
+- ✗ Truncation footers with recovery hints
+- ✗ Structural summarization (collapse braces)
+- ✗ Archive/SQLite support
+- ✗ Multi-range selectors (`:5-16,960-973`)
+- ✗ Prose column cap
+- ✗ Hash line anchors
+
+**Estimated LOC to Add**: 1,200-1,500 (including tests)
+
+### 3.2 EDIT Tool Gaps
+
+**File**: `rust/crates/runtime/src/file_ops.rs:760`
+
+**Current**: Basic string replacement works  
+**Missing**:
+- ✗ Rich patch metadata (line numbers, context lines)
+
+**Estimated LOC to Add**: 200-300
+
+### 3.3 SEARCH Tool Gaps
+
+**File**: `rust/crates/tools/src/lib.rs` (grep search)
+
+**Current**: Basic regex with context  
+**Missing**:
+- ✗ Advanced filtering (file type, glob exclude)
+- ✗ Structured output format
+
+**Estimated LOC to Add**: 300-400
+
+### 3.4 FIND Tool Gaps
+
+**File**: `rust/crates/tools/src/lib.rs` (glob search)
+
+**Current**: Basic glob expansion  
+**Missing**:
+- ✗ Recursive globs
+- ✗ Gitignore filtering
+- ✗ Hidden file control
+- ✗ File metadata
+
+**Estimated LOC to Add**: 200-300
+
+---
+
+## 4. IMPLEMENTATION PLAN (BATCHED)
+
+### Batch 1: READ Tool (Priority P0)
+- Add line range selector parsing
+- Implement `:raw` mode
+- ✓ Implement `:conflicts` mode
+- Add truncation footers with recovery hints
+- Implement structural summarization
+- Add tests for all selector combinations
+
+**Files to Modify**:
+- `rust/crates/runtime/src/file_ops.rs` (read_file_in_workspace)
+- `rust/crates/tools/src/lib.rs` (ReadFileInput struct)
+- Tests in both
+
+**Size Estimate**: 1,200 LOC  
+**Complexity**: Medium (string parsing, output formatting)
+
+### Batch 2: EDIT Tool (Priority P1)
+- Add patch metadata to output
+- Ensure exact match semantics
+- Add comprehensive tests
+
+**Files to Modify**:
+- `rust/crates/runtime/src/file_ops.rs` (edit_file_in_workspace)
+- Tests
+
+**Size Estimate**: 200 LOC  
+**Complexity**: Low
+
+### Batch 3: SEARCH/FIND Tools (Priority P1)
+- Enhance grep/find with GJC-compatible filtering
+- Add structured output format
+- Add metadata (file type, modified time)
+
+**Files to Modify**:
+- `rust/crates/tools/src/lib.rs` (glob_search, grep_search)
+- `rust/crates/runtime/src/file_ops.rs`
+
+**Size Estimate**: 500 LOC  
+**Complexity**: Low-Medium
+
+---
+
+## 5. VERIFICATION STRATEGY
+
+Each batch will include:
+1. **Semantic Tests**: Verify tool inputs/outputs match GJC reference
+2. **Edge Case Tests**: Line ranges, truncation, archives, etc.
+3. **Integration Tests**: End-to-end with claw CLI
+4. **Parity Shadow Test**: Run same inputs against both GJC and claw-code, compare outputs
+
+---
+
+## 6. ROLLOUT SCHEDULE
+
+- **Batch 1 (READ)**: Week 1 - Enable most impactful tool first
+- **Batch 2 (EDIT)**: Week 1-2 - Quick follow-up
+- **Batch 3 (SEARCH/FIND)**: Week 2 - Lower priority but valuable for discoverability
+
+---
+
+## 7. REFERENCES
+
+- GJC Read Tool: `/home/bellman/Workspace/gajae-code/packages/coding-agent/src/tools/read.ts`
+- claw-code file_ops: `rust/crates/runtime/src/file_ops.rs`
+- claw-code tools: `rust/crates/tools/src/lib.rs`
+- Gap Matrix: `docs/gjc-compat/gap-matrix.md`
@@ -41,7 +41,7 @@ TUI rule: formatting fns take `&mut impl Write`, never stdout directly. Never mi

 Library crates don't carry the `claw-` prefix. Binary crates do (except legacy `rusty-claude-cli`).

-Workspace version is `0.1.3`, `publish = false`, MIT license.
+Workspace version is `0.1.4`, `publish = false`, MIT license.

 No rust-toolchain file, no MSRV. CI pins `dtolnay/rust-toolchain@stable`.

@@ -93,7 +93,7 @@ checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"

 [[package]]
 name = "api"
-version = "0.1.3"
+version = "0.1.4"
 dependencies = [
 "criterion",
 "reqwest",
@@ -478,7 +478,7 @@ checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"

 [[package]]
 name = "claw-analog"
-version = "0.1.3"
+version = "0.1.4"
 dependencies = [
 "api",
 "clap",
@@ -498,7 +498,7 @@ dependencies = [

 [[package]]
 name = "claw-rag-service"
-version = "0.1.3"
+version = "0.1.4"
 dependencies = [
 "axum 0.8.9",
 "blake3",
@@ -531,7 +531,7 @@ checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"

 [[package]]
 name = "commands"
-version = "0.1.3"
+version = "0.1.4"
 dependencies = [
 "plugins",
 "runtime",
@@ -540,7 +540,7 @@ dependencies = [

 [[package]]
 name = "compat-harness"
-version = "0.1.3"
+version = "0.1.4"
 dependencies = [
 "commands",
 "runtime",
@@ -1568,7 +1568,7 @@ dependencies = [

 [[package]]
 name = "mock-anthropic-service"
-version = "0.1.3"
+version = "0.1.4"
 dependencies = [
 "api",
 "serde_json",
@@ -1761,7 +1761,7 @@ dependencies = [

 [[package]]
 name = "plugins"
-version = "0.1.3"
+version = "0.1.4"
 dependencies = [
 "serde",
 "serde_json",
@@ -2136,7 +2136,7 @@ dependencies = [

 [[package]]
 name = "runtime"
-version = "0.1.3"
+version = "0.1.4"
 dependencies = [
 "glob",
 "plugins",
@@ -2261,13 +2261,14 @@ checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"

 [[package]]
 name = "rusty-claude-cli"
-version = "0.1.3"
+version = "0.1.4"
 dependencies = [
 "api",
 "commands",
 "crossterm",
 "log",
 "mock-anthropic-service",
+ "nix",
 "plugins",
 "pulldown-cmark",
 "runtime",
@@ -2333,7 +2334,7 @@ checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"

 [[package]]
 name = "sdk"
-version = "0.1.0"
+version = "0.1.4"
 dependencies = [
 "futures-util",
 "serde",
@@ -2619,7 +2620,7 @@ dependencies = [

 [[package]]
 name = "telemetry"
-version = "0.1.3"
+version = "0.1.4"
 dependencies = [
 "serde",
 "serde_json",
@@ -2906,7 +2907,7 @@ dependencies = [

 [[package]]
 name = "tools"
-version = "0.1.3"
+version = "0.1.4"
 dependencies = [
 "api",
 "aspect-core",
@@ -3,7 +3,7 @@ members = ["crates/*"]
 resolver = "2"

 [workspace.package]
-version = "0.1.3"
+version = "0.1.4"
 edition = "2021"
 license = "MIT"
 publish = false
@@ -15,13 +15,15 @@ pub enum ProviderClient {

 /// Provider selected explicitly by persisted/runtime configuration.
 ///
-/// This is intentionally separate from `ProviderKind`: DashScope speaks the
-/// OpenAI-compatible wire protocol but remains a distinct configured provider.
+/// This is intentionally separate from `ProviderKind`: Custom OpenAI and
+/// DashScope speak the OpenAI-compatible wire protocol but remain distinct
+/// configured providers.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ProviderConfigKind {
    Anthropic,
    Xai,
    OpenAi,
+    CustomOpenAi,
    DashScope,
 }

@@ -96,9 +98,12 @@ impl ProviderClient {

                Ok(Self::Xai(client))
            }
-            ProviderConfigKind::OpenAi | ProviderConfigKind::DashScope => {
+            ProviderConfigKind::OpenAi
+            | ProviderConfigKind::CustomOpenAi
+            | ProviderConfigKind::DashScope => {
                let compat = match config.kind {
                    ProviderConfigKind::OpenAi => OpenAiCompatConfig::openai(),
+                    ProviderConfigKind::CustomOpenAi => OpenAiCompatConfig::custom_openai(),
                    ProviderConfigKind::DashScope => OpenAiCompatConfig::dashscope(),
                    _ => unreachable!("non-OpenAI provider reached compatibility path"),
                };
@@ -403,6 +408,56 @@ mod tests {
        }
    }

+    #[test]
+    fn persisted_custom_openai_uses_its_own_environment_namespace() {
+        let _lock = env_lock();
+        let _custom_key = EnvVarGuard::set("CLAWCUSTOMOPENAI_API_KEY", Some("custom-key"));
+        let _custom_url = EnvVarGuard::set(
+            "CLAWCUSTOMOPENAI_BASE_URL",
+            Some("https://custom.example/v1"),
+        );
+        let _openai_key = EnvVarGuard::set("OPENAI_API_KEY", Some("openai-key"));
+        let _openai_url = EnvVarGuard::set("OPENAI_BASE_URL", Some("https://openai.example/v1"));
+        let _ollama = EnvVarGuard::set("OLLAMA_HOST", Some("http://localhost:11434"));
+
+        let config = ProviderConfig {
+            kind: ProviderConfigKind::CustomOpenAi,
+            model: "qwen-plus".to_string(),
+            api_key: None,
+            base_url: None,
+        };
+
+        match ProviderClient::from_config(&config).expect("custom OpenAI config should succeed") {
+            ProviderClient::OpenAi(client) => {
+                assert_eq!(client.base_url(), "https://custom.example/v1");
+            }
+            other => panic!("Expected custom OpenAI provider, got: {other:?}"),
+        }
+    }
+
+    #[test]
+    fn persisted_custom_openai_does_not_reuse_openai_credentials() {
+        let _lock = env_lock();
+        let _custom_key = EnvVarGuard::set("CLAWCUSTOMOPENAI_API_KEY", None);
+        let _custom_url = EnvVarGuard::set(
+            "CLAWCUSTOMOPENAI_BASE_URL",
+            Some("https://custom.example/v1"),
+        );
+        let _openai_key = EnvVarGuard::set("OPENAI_API_KEY", Some("openai-key"));
+        let _ollama = EnvVarGuard::set("OLLAMA_HOST", Some("http://localhost:11434"));
+
+        let config = ProviderConfig {
+            kind: ProviderConfigKind::CustomOpenAi,
+            model: "gpt-5".to_string(),
+            api_key: None,
+            base_url: None,
+        };
+
+        let error = ProviderClient::from_config(&config)
+            .expect_err("custom OpenAI must require its own credentials");
+        assert!(error.to_string().contains("CLAWCUSTOMOPENAI_API_KEY"));
+    }
+
    #[test]
    fn dashscope_model_uses_dashscope_config_not_openai() {
        // Regression: qwen-plus was being routed to OpenAiCompatConfig::openai()
@@ -42,6 +42,7 @@ pub struct OpenAiCompatConfig {

 const XAI_ENV_VARS: &[&str] = &["XAI_API_KEY"];
 const OPENAI_ENV_VARS: &[&str] = &["OPENAI_API_KEY"];
+const CUSTOM_OPENAI_ENV_VARS: &[&str] = &["CLAWCUSTOMOPENAI_API_KEY"];
 const DASHSCOPE_ENV_VARS: &[&str] = &["DASHSCOPE_API_KEY"];

 // Provider-specific request body size limits in bytes
@@ -80,6 +81,18 @@ impl OpenAiCompatConfig {
        }
    }

+    /// OpenAI-compatible endpoint with its own environment namespace and no default URL.
+    #[must_use]
+    pub const fn custom_openai() -> Self {
+        Self {
+            provider_name: "Custom OpenAI",
+            api_key_env: "CLAWCUSTOMOPENAI_API_KEY",
+            base_url_env: "CLAWCUSTOMOPENAI_BASE_URL",
+            default_base_url: "",
+            max_request_body_bytes: OPENAI_MAX_REQUEST_BODY_BYTES,
+        }
+    }
+
    /// Alibaba `DashScope` compatible-mode endpoint (Qwen family models).
    /// Uses the OpenAI-compatible REST shape at /compatible-mode/v1.
    /// Requested via Discord #clawcode-get-help: native Alibaba API for
@@ -100,6 +113,7 @@ impl OpenAiCompatConfig {
        match self.provider_name {
            "xAI" => XAI_ENV_VARS,
            "OpenAI" => OPENAI_ENV_VARS,
+            "Custom OpenAI" => CUSTOM_OPENAI_ENV_VARS,
            "DashScope" => DASHSCOPE_ENV_VARS,
            _ => &[],
        }
@@ -82,7 +82,7 @@ async fn send_message_posts_json_and_parses_response() {
    );
    assert_eq!(
        request.headers.get("user-agent").map(String::as_str),
-        Some("claude-code/0.1.3")
+        Some("claude-code/0.1.4")
    );
    assert_eq!(
        request.headers.get("anthropic-beta").map(String::as_str),
@@ -163,6 +163,20 @@ const SLASH_COMMAND_SPECS: &[SlashCommandSpec] = &[
        argument_hint: None,
        resume_supported: true,
    },
+    SlashCommandSpec {
+        name: "tools",
+        aliases: &[],
+        summary: "List available tools and their descriptions",
+        argument_hint: None,
+        resume_supported: true,
+    },
+    SlashCommandSpec {
+        name: "info",
+        aliases: &[],
+        summary: "Show runtime information about claw-code",
+        argument_hint: None,
+        resume_supported: true,
+    },
    SlashCommandSpec {
        name: "bughunter",
        aliases: &[],
@@ -1091,6 +1105,8 @@ pub enum SlashCommand {
    Init,
    Diff,
    Version,
+    Tools,
+    Info,
    Export {
        path: Option<String>,
    },
@@ -1392,6 +1408,14 @@ pub fn validate_slash_command_input(
            validate_no_args(command, &args)?;
            SlashCommand::Version
        }
+        "tools" => {
+            validate_no_args(command, &args)?;
+            SlashCommand::Tools
+        }
+        "info" => {
+            validate_no_args(command, &args)?;
+            SlashCommand::Info
+        }
        "export" => SlashCommand::Export { path: remainder },
        "session" => parse_session_command(&args)?,
        "plugin" | "plugins" | "marketplace" => parse_plugin_command(&args)?,
@@ -5297,60 +5321,6 @@ fn mcp_server_json(name: &str, server: &ScopedMcpServerConfig) -> Value {
    })
 }

-fn render_session_status(session: &Session) -> String {
-    let message_count = session.messages.len();
-    let mut total_input = 0u32;
-    let mut total_output = 0u32;
-    for msg in &session.messages {
-        if let Some(usage) = msg.usage {
-            total_input = total_input.saturating_add(usage.input_tokens);
-            total_output = total_output.saturating_add(usage.output_tokens);
-        }
-    }
-    format!(
-        "Session {}: {} messages, {} input tokens, {} output tokens",
-        &session.session_id[0..8],
-        message_count,
-        total_input,
-        total_output
-    )
-}
-
-fn render_token_cost(session: &Session) -> String {
-    let mut total_input = 0u32;
-    let mut total_output = 0u32;
-    let mut cache_creation = 0u32;
-    let mut cache_read = 0u32;
-    for msg in &session.messages {
-        if let Some(usage) = msg.usage {
-            total_input = total_input.saturating_add(usage.input_tokens);
-            total_output = total_output.saturating_add(usage.output_tokens);
-            cache_creation = cache_creation.saturating_add(usage.cache_creation_input_tokens);
-            cache_read = cache_read.saturating_add(usage.cache_read_input_tokens);
-        }
-    }
-    format!(
-        "Cumulative token usage for this session:
-  Input tokens: {}
-  Output tokens: {}
-  Cache creation tokens: {}
-  Cache read tokens: {}
-  Total input: {}",
-        total_input,
-        total_output,
-        cache_creation,
-        cache_read,
-        total_input
-            .saturating_add(cache_creation)
-            .saturating_add(cache_read)
-    )
-}
-
-fn render_version_info() -> String {
-    let version = env!("CARGO_PKG_VERSION");
-    format!("claw-code version {}", version)
-}
-
 #[must_use]
 pub fn handle_slash_command(
    input: &str,
@@ -5388,19 +5358,8 @@ pub fn handle_slash_command(
            message: render_slash_command_help(),
            session: session.clone(),
        }),
-        SlashCommand::Status => Some(SlashCommandResult {
-            message: render_session_status(session),
-            session: session.clone(),
-        }),
-        SlashCommand::Cost => Some(SlashCommandResult {
-            message: render_token_cost(session),
-            session: session.clone(),
-        }),
-        SlashCommand::Version => Some(SlashCommandResult {
-            message: render_version_info(),
-            session: session.clone(),
-        }),
-        SlashCommand::Bughunter { .. }
+        SlashCommand::Status
+        | SlashCommand::Bughunter { .. }
        | SlashCommand::Commit
        | SlashCommand::Pr { .. }
        | SlashCommand::Issue { .. }
@@ -5411,6 +5370,7 @@ pub fn handle_slash_command(
        | SlashCommand::Model { .. }
        | SlashCommand::Permissions { .. }
        | SlashCommand::Clear { .. }
+        | SlashCommand::Cost
        | SlashCommand::Resume { .. }
        | SlashCommand::Config { .. }
        | SlashCommand::Workspace { .. }
@@ -5418,6 +5378,7 @@ pub fn handle_slash_command(
        | SlashCommand::Memory
        | SlashCommand::Init
        | SlashCommand::Diff
+        | SlashCommand::Version
        | SlashCommand::Export { .. }
        | SlashCommand::Session { .. }
        | SlashCommand::Plugins { .. }
@@ -5466,6 +5427,8 @@ pub fn handle_slash_command(
        | SlashCommand::History { .. }
        | SlashCommand::Team { .. }
        | SlashCommand::Setup
+        | SlashCommand::Tools
+        | SlashCommand::Info
        | SlashCommand::Unknown(_) => None,
    }
 }
@@ -6083,7 +6046,7 @@ mod tests {
        assert!(!help.contains("/login"));
        assert!(!help.contains("/logout"));
        assert!(help.contains("/setup"));
-        assert_eq!(slash_command_specs().len(), 140);
+        assert_eq!(slash_command_specs().len(), 142);
        assert!(resume_supported_slash_commands().len() >= 39);
    }

@@ -6256,6 +6219,7 @@ mod tests {
    fn ignores_unknown_or_runtime_bound_slash_commands() {
        let session = Session::new();
        assert!(handle_slash_command("/unknown", &session, CompactionConfig::default()).is_none());
+        assert!(handle_slash_command("/status", &session, CompactionConfig::default()).is_none());
        assert!(handle_slash_command("/sandbox", &session, CompactionConfig::default()).is_none());
        assert!(
            handle_slash_command("/bughunter", &session, CompactionConfig::default()).is_none()
@@ -6287,6 +6251,7 @@ mod tests {
            handle_slash_command("/clear --confirm", &session, CompactionConfig::default())
                .is_none()
        );
+        assert!(handle_slash_command("/cost", &session, CompactionConfig::default()).is_none());
        assert!(handle_slash_command(
            "/resume session.json",
            &session,
@@ -6305,6 +6270,9 @@ mod tests {
        );
        assert!(handle_slash_command("/mcp list", &session, CompactionConfig::default()).is_none());
        assert!(handle_slash_command("/diff", &session, CompactionConfig::default()).is_none());
+        assert!(handle_slash_command("/version", &session, CompactionConfig::default()).is_none());
+        assert!(handle_slash_command("/tools", &session, CompactionConfig::default()).is_none());
+        assert!(handle_slash_command("/info", &session, CompactionConfig::default()).is_none());
        assert!(
            handle_slash_command("/export note.txt", &session, CompactionConfig::default())
                .is_none()
@@ -7266,79 +7234,4 @@ mod tests {
        let _ = fs::remove_dir_all(config_home);
        let _ = fs::remove_dir_all(bundled_root);
    }
-
-    #[test]
-    fn status_command_shows_session_info() {
-        use runtime::TokenUsage;
-
-        let mut session = Session::new();
-        session.messages.push(ConversationMessage {
-            role: MessageRole::User,
-            blocks: vec![ContentBlock::Text {
-                text: "hello".to_string(),
-            }],
-            usage: Some(TokenUsage {
-                input_tokens: 10,
-                output_tokens: 20,
-                cache_creation_input_tokens: 0,
-                cache_read_input_tokens: 0,
-            }),
-        });
-        session.messages.push(ConversationMessage {
-            role: MessageRole::Assistant,
-            blocks: vec![ContentBlock::Text {
-                text: "response".to_string(),
-            }],
-            usage: Some(TokenUsage {
-                input_tokens: 5,
-                output_tokens: 15,
-                cache_creation_input_tokens: 0,
-                cache_read_input_tokens: 0,
-            }),
-        });
-
-        let result = handle_slash_command("/status", &session, CompactionConfig::default())
-            .expect("/status should be handled");
-        assert!(result.message.contains("2 messages"));
-        assert!(result.message.contains("15 input tokens"));
-        assert!(result.message.contains("35 output tokens"));
-        assert_eq!(result.session, session);
-    }
-
-    #[test]
-    fn cost_command_shows_token_usage() {
-        use runtime::TokenUsage;
-
-        let mut session = Session::new();
-        session.messages.push(ConversationMessage {
-            role: MessageRole::User,
-            blocks: vec![ContentBlock::Text {
-                text: "hello".to_string(),
-            }],
-            usage: Some(TokenUsage {
-                input_tokens: 100,
-                output_tokens: 200,
-                cache_creation_input_tokens: 50,
-                cache_read_input_tokens: 25,
-            }),
-        });
-
-        let result = handle_slash_command("/cost", &session, CompactionConfig::default())
-            .expect("/cost should be handled");
-        assert!(result.message.contains("100"));
-        assert!(result.message.contains("200"));
-        assert!(result.message.contains("50"));
-        assert!(result.message.contains("25"));
-        assert!(result.message.contains("Cumulative token usage"));
-        assert_eq!(result.session, session);
-    }
-
-    #[test]
-    fn version_command_shows_version() {
-        let session = Session::new();
-        let result = handle_slash_command("/version", &session, CompactionConfig::default())
-            .expect("/version should be handled");
-        assert!(result.message.contains("claw-code version"));
-        assert_eq!(result.session, session);
-    }
 }
@@ -1,5 +1,9 @@
 use std::collections::BTreeMap;
 use std::fmt::{Display, Formatter};
+use std::sync::{
+    atomic::{AtomicBool, Ordering},
+    Arc,
+};

 use serde_json::{Map, Value};
 use telemetry::SessionTracer;
@@ -53,6 +57,41 @@ pub struct PromptCacheEvent {
    pub token_drop: u32,
 }

+/// Shared flag used to request graceful interruption of a running turn.
+///
+/// Cloning shares the underlying flag, mirroring
+/// [`HookAbortSignal`](crate::hooks::HookAbortSignal). An input listener
+/// (e.g. Esc or Ctrl+C handling in the CLI) sets the flag while the
+/// conversation loop and the streaming API client poll it at safe points.
+/// When the flag is observed, the turn winds down without treating the
+/// stop as a failure: pending tool calls receive synthesized error
+/// results so the session stays consistent, and [`TurnSummary`] reports
+/// `interrupted: true`.
+#[derive(Debug, Clone, Default)]
+pub struct TurnInterruptSignal {
+    interrupted: Arc<AtomicBool>,
+}
+
+impl TurnInterruptSignal {
+    #[must_use]
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn interrupt(&self) {
+        self.interrupted.store(true, Ordering::SeqCst);
+    }
+
+    #[must_use]
+    pub fn is_interrupted(&self) -> bool {
+        self.interrupted.load(Ordering::SeqCst)
+    }
+
+    pub fn reset(&self) {
+        self.interrupted.store(false, Ordering::SeqCst);
+    }
+}
+
 /// Minimal streaming API contract required by [`ConversationRuntime`].
 pub trait ApiClient {
    fn stream(&mut self, request: ApiRequest) -> Result<Vec<AssistantEvent>, RuntimeError>;
@@ -118,6 +157,7 @@ pub struct TurnSummary {
    pub iterations: usize,
    pub usage: TokenUsage,
    pub auto_compaction: Option<AutoCompactionEvent>,
+    pub interrupted: bool,
 }

 /// Details about automatic session compaction applied during a turn.
@@ -138,6 +178,7 @@ pub struct ConversationRuntime<C, T> {
    hook_runner: HookRunner,
    auto_compaction_input_tokens_threshold: u32,
    hook_abort_signal: HookAbortSignal,
+    turn_interrupt_signal: TurnInterruptSignal,
    hook_progress_reporter: Option<Box<dyn HookProgressReporter>>,
    session_tracer: Option<SessionTracer>,
 }
@@ -192,6 +233,7 @@ where
            hook_runner,
            auto_compaction_input_tokens_threshold: auto_compaction_threshold_from_env(),
            hook_abort_signal: HookAbortSignal::default(),
+            turn_interrupt_signal: TurnInterruptSignal::default(),
            hook_progress_reporter: None,
            session_tracer: None,
        }
@@ -222,6 +264,15 @@ where
        self
    }

+    #[must_use]
+    pub fn with_turn_interrupt_signal(
+        mut self,
+        turn_interrupt_signal: TurnInterruptSignal,
+    ) -> Self {
+        self.turn_interrupt_signal = turn_interrupt_signal;
+        self
+    }
+
    #[must_use]
    pub fn with_hook_progress_reporter(
        mut self,
@@ -355,8 +406,14 @@ where
        let mut prompt_cache_events = Vec::new();
        let mut iterations = 0;
        let mut auto_compaction = None;
+        let mut interrupted = false;

        loop {
+            if self.turn_interrupt_signal.is_interrupted() {
+                self.record_turn_interrupted(iterations, "before_request");
+                interrupted = true;
+                break;
+            }
            iterations += 1;
            if iterations > self.max_iterations {
                let error = RuntimeError::new(
@@ -373,6 +430,14 @@ where
            let events = match self.api_client.stream(request) {
                Ok(events) => events,
                Err(error) => {
+                    if self.turn_interrupt_signal.is_interrupted() {
+                        // The client aborted because the user interrupted the
+                        // turn; any partial response is discarded and the stop
+                        // is reported as an interruption rather than a failure.
+                        self.record_turn_interrupted(iterations, "during_request");
+                        interrupted = true;
+                        break;
+                    }
                    self.record_turn_failed(iterations, &error);
                    return Err(error);
                }
@@ -421,6 +486,25 @@ where
            }

            for (tool_use_id, tool_name, input) in pending_tool_uses {
+                if interrupted || self.turn_interrupt_signal.is_interrupted() {
+                    // Every pending tool_use must still receive a tool_result
+                    // so the session stays valid for the next request.
+                    if !interrupted {
+                        self.record_turn_interrupted(iterations, "before_tool");
+                        interrupted = true;
+                    }
+                    let result_message = ConversationMessage::tool_result(
+                        tool_use_id,
+                        tool_name,
+                        "Interrupted by user before this tool could run.",
+                        true,
+                    );
+                    self.session
+                        .push_message(result_message.clone())
+                        .map_err(|error| RuntimeError::new(error.to_string()))?;
+                    tool_results.push(result_message);
+                    continue;
+                }
                let pre_hook_result = self.run_pre_tool_use_hook(&tool_name, &input);
                let effective_input = pre_hook_result
                    .updated_input()
@@ -520,6 +604,10 @@ where
                self.record_tool_finished(iterations, &result_message);
                tool_results.push(result_message);
            }
+
+            if interrupted {
+                break;
+            }
        }

        let summary = TurnSummary {
@@ -529,8 +617,11 @@ where
            iterations,
            usage: self.usage_tracker.cumulative_usage(),
            auto_compaction,
+            interrupted,
        };
-        self.record_turn_completed(&summary);
+        if !interrupted {
+            self.record_turn_completed(&summary);
+        }

        Ok(summary)
    }
@@ -694,6 +785,17 @@ where
        session_tracer.record("turn_completed", attributes);
    }

+    fn record_turn_interrupted(&self, iteration: usize, phase: &str) {
+        let Some(session_tracer) = &self.session_tracer else {
+            return;
+        };
+
+        let mut attributes = Map::new();
+        attributes.insert("iteration".to_string(), Value::from(iteration as u64));
+        attributes.insert("phase".to_string(), Value::String(phase.to_string()));
+        session_tracer.record("turn_interrupted", attributes);
+    }
+
    fn record_turn_failed(&self, iteration: usize, error: &RuntimeError) {
        let Some(session_tracer) = &self.session_tracer else {
            return;
@@ -855,7 +957,8 @@ mod tests {
    use super::{
        build_assistant_message, parse_auto_compaction_threshold, ApiClient, ApiRequest,
        AssistantEvent, AutoCompactionEvent, ConversationRuntime, PromptCacheEvent, RuntimeError,
-        StaticToolExecutor, ToolExecutor, DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD,
+        StaticToolExecutor, ToolExecutor, TurnInterruptSignal,
+        DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD,
    };
    use crate::compact::CompactionConfig;
    use crate::config::{RuntimeFeatureConfig, RuntimeHookConfig};
@@ -1956,4 +2059,165 @@ mod tests {
        // then
        assert_eq!(error.to_string(), "upstream failed");
    }
+
+    #[test]
+    fn interrupt_before_first_request_skips_the_api_call() {
+        struct UnreachableApi;
+
+        impl ApiClient for UnreachableApi {
+            fn stream(
+                &mut self,
+                _request: ApiRequest,
+            ) -> Result<Vec<AssistantEvent>, RuntimeError> {
+                unreachable!("interrupted turn must not reach the API")
+            }
+        }
+
+        // given
+        let interrupt = TurnInterruptSignal::new();
+        interrupt.interrupt();
+        let mut runtime = ConversationRuntime::new(
+            Session::new(),
+            UnreachableApi,
+            StaticToolExecutor::new(),
+            PermissionPolicy::new(PermissionMode::DangerFullAccess),
+            vec!["system".to_string()],
+        )
+        .with_turn_interrupt_signal(interrupt);
+
+        // when
+        let summary = runtime
+            .run_turn("hello", None)
+            .expect("interruption should not be reported as a failure");
+
+        // then
+        assert!(summary.interrupted);
+        assert_eq!(summary.iterations, 0);
+        assert!(summary.assistant_messages.is_empty());
+        assert!(summary.tool_results.is_empty());
+        assert_eq!(summary.auto_compaction, None);
+        assert_eq!(runtime.session().messages.len(), 1);
+        assert_eq!(runtime.session().messages[0].role, MessageRole::User);
+    }
+
+    #[test]
+    fn interrupt_after_stream_synthesizes_results_for_pending_tools() {
+        struct ToolUseApi {
+            interrupt: TurnInterruptSignal,
+        }
+
+        impl ApiClient for ToolUseApi {
+            fn stream(
+                &mut self,
+                _request: ApiRequest,
+            ) -> Result<Vec<AssistantEvent>, RuntimeError> {
+                // Simulate the user pressing Esc while the response streams in.
+                self.interrupt.interrupt();
+                Ok(vec![
+                    AssistantEvent::TextDelta("Running the tool.".to_string()),
+                    AssistantEvent::ToolUse {
+                        id: "tool-1".to_string(),
+                        name: "add".to_string(),
+                        input: "2,2".to_string(),
+                    },
+                    AssistantEvent::MessageStop,
+                ])
+            }
+        }
+
+        // given
+        let interrupt = TurnInterruptSignal::new();
+        let mut runtime = ConversationRuntime::new(
+            Session::new(),
+            ToolUseApi {
+                interrupt: interrupt.clone(),
+            },
+            StaticToolExecutor::new()
+                .register("add", |_input| panic!("interrupted tool must not run")),
+            PermissionPolicy::new(PermissionMode::DangerFullAccess),
+            vec!["system".to_string()],
+        )
+        .with_turn_interrupt_signal(interrupt);
+
+        // when
+        let summary = runtime
+            .run_turn("what is 2 + 2?", None)
+            .expect("interruption should not be reported as a failure");
+
+        // then
+        assert!(summary.interrupted);
+        assert_eq!(summary.iterations, 1);
+        assert_eq!(summary.assistant_messages.len(), 1);
+        assert_eq!(summary.tool_results.len(), 1);
+        assert!(matches!(
+            &summary.tool_results[0].blocks[0],
+            ContentBlock::ToolResult {
+                tool_use_id,
+                is_error: true,
+                output,
+                ..
+            } if tool_use_id == "tool-1" && output.contains("Interrupted by user")
+        ));
+        // user text, assistant tool_use, synthesized tool_result
+        assert_eq!(runtime.session().messages.len(), 3);
+        assert!(matches!(
+            runtime.session().messages[2].blocks[0],
+            ContentBlock::ToolResult { is_error: true, .. }
+        ));
+    }
+
+    #[test]
+    fn stream_error_during_interrupt_is_reported_as_interruption() {
+        struct AbortedApi {
+            interrupt: TurnInterruptSignal,
+        }
+
+        impl ApiClient for AbortedApi {
+            fn stream(
+                &mut self,
+                _request: ApiRequest,
+            ) -> Result<Vec<AssistantEvent>, RuntimeError> {
+                // Simulate the streaming client aborting the connection after
+                // observing the interrupt flag mid-stream.
+                self.interrupt.interrupt();
+                Err(RuntimeError::new("request aborted"))
+            }
+        }
+
+        // given
+        let sink = Arc::new(MemoryTelemetrySink::default());
+        let tracer = SessionTracer::new("session-interrupt", sink.clone());
+        let interrupt = TurnInterruptSignal::new();
+        let mut runtime = ConversationRuntime::new(
+            Session::new(),
+            AbortedApi {
+                interrupt: interrupt.clone(),
+            },
+            StaticToolExecutor::new(),
+            PermissionPolicy::new(PermissionMode::DangerFullAccess),
+            vec!["system".to_string()],
+        )
+        .with_turn_interrupt_signal(interrupt)
+        .with_session_tracer(tracer);
+
+        // when
+        let summary = runtime
+            .run_turn("hello", None)
+            .expect("interrupt-driven aborts should not surface as errors");
+
+        // then
+        assert!(summary.interrupted);
+        assert!(summary.assistant_messages.is_empty());
+        let trace_names = sink
+            .events()
+            .iter()
+            .filter_map(|event| match event {
+                TelemetryEvent::SessionTrace(trace) => Some(trace.name.clone()),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+        assert!(trace_names.iter().any(|name| name == "turn_interrupted"));
+        assert!(!trace_names.iter().any(|name| name == "turn_failed"));
+        assert!(!trace_names.iter().any(|name| name == "turn_completed"));
+    }
 }
@@ -10,6 +10,8 @@ use regex::RegexBuilder;
 use serde::{Deserialize, Serialize};
 use walkdir::{DirEntry, WalkDir};

+use crate::line_range_selector::{self, LineRangeSelector};
+
 /// Maximum file size that can be read (10 MB).
 const MAX_READ_SIZE: u64 = 10 * 1024 * 1024;

@@ -88,6 +90,9 @@ pub struct ReadFileOutput {
    #[serde(rename = "type")]
    pub kind: String,
    pub file: TextFilePayload,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "truncationFooter")]
+    pub truncation_footer: Option<String>,
 }

 /// Structured patch hunk emitted by write and edit operations.
@@ -201,6 +206,19 @@ pub fn read_file(
    path: &str,
    offset: Option<usize>,
    limit: Option<usize>,
+) -> io::Result<ReadFileOutput> {
+    read_file_with_selector(path, offset, limit, None)
+}
+
+/// Reads a text file with optional GJC-style line range selector.
+///
+/// The selector takes precedence over offset/limit if provided.
+/// Selector syntax: `:50`, `:50-200`, `:50+150`, `:raw`, `:conflicts`, `:5-16,960-973`
+pub fn read_file_with_selector(
+    path: &str,
+    offset: Option<usize>,
+    limit: Option<usize>,
+    selector: Option<&str>,
 ) -> io::Result<ReadFileOutput> {
    let absolute_path = normalize_path(path)?;

@@ -227,11 +245,56 @@ pub fn read_file(

    let content = fs::read_to_string(&absolute_path)?;
    let lines: Vec<&str> = content.lines().collect();
-    let start_index = offset.unwrap_or(0).min(lines.len());
-    let end_index = limit.map_or(lines.len(), |limit| {
-        start_index.saturating_add(limit).min(lines.len())
-    });
-    let selected = lines[start_index..end_index].join("\n");
+    let total_lines = lines.len();
+
+    // Special handling for conflicts selector
+    if selector == Some("conflicts") {
+        let conflicts = extract_merge_conflicts(&lines);
+        let (selected, num_lines) = if conflicts.is_empty() {
+            (format!("No unresolved git merge conflicts in {}.", path), 1)
+        } else {
+            let display_path = absolute_path
+                .file_name()
+                .and_then(|n| n.to_str())
+                .unwrap_or(path);
+            let summary = format_conflict_summary(&conflicts, display_path);
+            let summary_lines = summary.lines().count();
+            (summary, summary_lines)
+        };
+
+        return Ok(ReadFileOutput {
+            kind: String::from("text"),
+            file: TextFilePayload {
+                file_path: absolute_path.to_string_lossy().into_owned(),
+                content: selected,
+                num_lines,
+                start_line: 1,
+                total_lines,
+            },
+            truncation_footer: None,
+        });
+    }
+
+    // Determine which lines to select
+    let (start_index, end_index, truncation_footer) = if let Some(sel) = selector {
+        // Parse and apply selector
+        let parsed = line_range_selector::parse_selector(sel)
+            .map_err(|e| io::Error::new(io::ErrorKind::InvalidInput, e.to_string()))?;
+        apply_line_selector(&lines, parsed, path)
+    } else {
+        // Use offset/limit for backward compatibility
+        let start = offset.unwrap_or(0).min(lines.len());
+        let end = limit.map_or(lines.len(), |lim| {
+            start.saturating_add(lim).min(lines.len())
+        });
+        (start, end, None)
+    };
+
+    let selected = if start_index < end_index {
+        lines[start_index..end_index].join("\n")
+    } else {
+        String::new()
+    };

    Ok(ReadFileOutput {
        kind: String::from("text"),
@@ -240,11 +303,255 @@ pub fn read_file(
            content: selected,
            num_lines: end_index.saturating_sub(start_index),
            start_line: start_index.saturating_add(1),
-            total_lines: lines.len(),
+            total_lines,
        },
+        truncation_footer,
    })
 }

+/// Represents a merge conflict block in a file.
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct ConflictBlock {
+    start_line: usize,        // 1-based line number where <<<<<<< starts
+    separator_line: usize,    // 1-based line number where ======= is
+    end_line: usize,          // 1-based line number where >>>>>>> is
+    base_line: Option<usize>, // 1-based line number where ||||||| is (for 3-way)
+    ours_label: Option<String>,
+    base_label: Option<String>,
+    theirs_label: Option<String>,
+}
+
+/// Scans lines for unresolved git merge conflict blocks.
+fn extract_merge_conflicts(lines: &[&str]) -> Vec<ConflictBlock> {
+    let mut blocks = Vec::new();
+    let mut i = 0;
+
+    const OURS_PREFIX: &str = "<<<<<<<";
+    const BASE_PREFIX: &str = "|||||||";
+    const SEPARATOR: &str = "=======";
+    const THEIRS_PREFIX: &str = ">>>>>>>";
+
+    while i < lines.len() {
+        let line = lines[i];
+
+        // Check for start of conflict block
+        if let Some(label) = extract_marker_label(line, OURS_PREFIX) {
+            let ours_label = if label.is_empty() {
+                None
+            } else {
+                Some(label.to_string())
+            };
+            let start_line = i + 1; // Convert to 1-based
+            let mut separator_line = None;
+            let mut base_line = None;
+            let mut base_label = None;
+            let mut end_line = None;
+            let mut theirs_label = None;
+            let mut j = i + 1;
+
+            // Look for separator, optional base marker, and end marker
+            while j < lines.len() {
+                let current = lines[j];
+
+                // Check for base marker (3-way)
+                if let Some(label) = extract_marker_label(current, BASE_PREFIX) {
+                    if base_line.is_none() {
+                        base_line = Some(j + 1);
+                        base_label = if label.is_empty() {
+                            None
+                        } else {
+                            Some(label.to_string())
+                        };
+                        j += 1;
+                        continue;
+                    }
+                }
+
+                // Check for separator
+                if current.trim() == SEPARATOR {
+                    if separator_line.is_none() {
+                        separator_line = Some(j + 1);
+                        j += 1;
+                        continue;
+                    }
+                }
+
+                // Check for end marker
+                if let Some(label) = extract_marker_label(current, THEIRS_PREFIX) {
+                    if separator_line.is_some() {
+                        end_line = Some(j + 1);
+                        theirs_label = if label.is_empty() {
+                            None
+                        } else {
+                            Some(label.to_string())
+                        };
+                        j += 1;
+                        break;
+                    }
+                }
+
+                j += 1;
+            }
+
+            // Only add if we found both separator and end marker
+            if let (Some(sep_line), Some(end)) = (separator_line, end_line) {
+                blocks.push(ConflictBlock {
+                    start_line,
+                    separator_line: sep_line,
+                    end_line: end,
+                    base_line,
+                    ours_label,
+                    base_label,
+                    theirs_label,
+                });
+                i = j;
+                continue;
+            }
+        }
+
+        i += 1;
+    }
+
+    blocks
+}
+
+/// Extract the optional label from a marker line.
+/// Returns the label text (stripped of leading/trailing spaces) if the line matches the prefix,
+/// or None otherwise.
+fn extract_marker_label<'a>(line: &'a str, prefix: &str) -> Option<&'a str> {
+    if line.starts_with(prefix) {
+        let rest = &line[prefix.len()..];
+        // Accept either just the prefix or prefix + single space + label
+        if rest.is_empty() {
+            Some("")
+        } else if rest.starts_with(' ') {
+            Some(rest[1..].trim())
+        } else {
+            None
+        }
+    } else {
+        None
+    }
+}
+
+/// Format conflict blocks as a summary index, like GJC's implementation.
+fn format_conflict_summary(conflicts: &[ConflictBlock], display_path: &str) -> String {
+    let mut output = Vec::new();
+    let total = conflicts.len();
+    let word = if total == 1 { "conflict" } else { "conflicts" };
+
+    output.push(format!(
+        "⚠ {} unresolved {} in {}",
+        total, word, display_path
+    ));
+
+    // Extract labels for header
+    let ours_label = conflicts.iter().find_map(|c| c.ours_label.as_ref());
+    let theirs_label = conflicts.iter().find_map(|c| c.theirs_label.as_ref());
+    let base_label = conflicts.iter().find_map(|c| c.base_label.as_ref());
+    let any_base = conflicts.iter().any(|c| c.base_line.is_some());
+
+    if let Some(label) = ours_label {
+        output.push(format!("- ours = {}", label));
+    }
+    if let Some(label) = theirs_label {
+        output.push(format!("- theirs = {}", label));
+    }
+    if any_base {
+        let base_name = base_label
+            .map(|l| l.to_string())
+            .unwrap_or_else(|| "(no label)".to_string());
+        output.push(format!("- base = {}", base_name));
+    }
+
+    output.push(
+        "NOTICE: Bulk-resolve with `write({ path: \"conflict://*\", content })`, or address a single block with `write({ path: \"conflict://<N>\", content })`. Inspect a block by reading `conflict://<N>` (add `/ours` / `/theirs` / `/base` for a single side).".to_string()
+    );
+    output.push(
+        "`content` shorthand: `@ours` / `@theirs` / `@base` / `@both` lines expand to the recorded sections; `@both` = ours-then-theirs. Non-token lines pass through verbatim.".to_string()
+    );
+    output.push(String::new());
+
+    // Format each conflict as a one-liner index
+    let id_width = total.to_string().len();
+    for (idx, conflict) in conflicts.iter().enumerate() {
+        let id = idx + 1;
+        let range = if conflict.start_line == conflict.end_line {
+            format!("L{}", conflict.start_line)
+        } else {
+            format!("L{}-{}", conflict.start_line, conflict.end_line)
+        };
+        let kind = if conflict.base_line.is_some() {
+            "  (3-way)"
+        } else {
+            ""
+        };
+        output.push(format!(
+            "#{:>width$}  {}{}",
+            id,
+            range,
+            kind,
+            width = id_width
+        ));
+    }
+
+    output.join("\n")
+}
+
+/// Apply a parsed line selector to file lines and return the selected range.
+///
+/// Returns (start_index, end_index, truncation_footer).
+fn apply_line_selector(
+    lines: &[&str],
+    selector: LineRangeSelector,
+    _file_path: &str,
+) -> (usize, usize, Option<String>) {
+    match selector {
+        LineRangeSelector::Raw => {
+            // Return entire file without truncation footer for raw mode
+            (0, lines.len(), None)
+        }
+        LineRangeSelector::Conflicts => {
+            // Conflicts are handled specially in read_file_with_selector, so this shouldn't be reached
+            (0, lines.len(), None)
+        }
+        LineRangeSelector::Lines(ranges) => {
+            // Collect all lines specified by ranges
+            let mut selected_indices = std::collections::BTreeSet::new();
+            for range in ranges {
+                let (start_zero, end_zero) = range.zero_indexed();
+                for i in start_zero..=end_zero.min(lines.len().saturating_sub(1)) {
+                    selected_indices.insert(i);
+                }
+            }
+
+            if selected_indices.is_empty() {
+                return (0, 0, None);
+            }
+
+            // Find contiguous blocks and return the first one (or could merge all)
+            let indices: Vec<usize> = selected_indices.iter().copied().collect();
+            let first = indices[0];
+            let last = indices[indices.len() - 1];
+
+            // Check if it's a contiguous range
+            let is_contiguous = (last - first + 1) == indices.len();
+
+            if is_contiguous {
+                (first, last + 1, None)
+            } else {
+                // Return all selected indices as one continuous block from first to last
+                // In the future, this could be improved to show multiple blocks
+                (first, last + 1, None)
+            }
+        }
+        LineRangeSelector::None => {
+            // No selector, return entire file
+            (0, lines.len(), None)
+        }
+    }
+}
+
 /// Replaces a file's contents and returns patch metadata.
 pub fn write_file(path: &str, content: &str) -> io::Result<WriteFileOutput> {
    if content.len() > MAX_WRITE_SIZE {
@@ -715,11 +1022,23 @@ pub fn read_file_in_workspace(
    offset: Option<usize>,
    limit: Option<usize>,
    workspace_root: &Path,
+) -> io::Result<ReadFileOutput> {
+    read_file_in_workspace_with_selector(path, offset, limit, None, workspace_root)
+}
+
+/// Read a file with workspace boundary enforcement and optional line range selector.
+#[allow(dead_code)]
+pub fn read_file_in_workspace_with_selector(
+    path: &str,
+    offset: Option<usize>,
+    limit: Option<usize>,
+    selector: Option<&str>,
+    workspace_root: &Path,
 ) -> io::Result<ReadFileOutput> {
    let absolute_path = normalize_path(path)?;
    let canonical_root = canonicalize_workspace_root(workspace_root);
    validate_workspace_boundary(&absolute_path, &canonical_root)?;
-    read_file(path, offset, limit)
+    read_file_with_selector(path, offset, limit, selector)
 }

 /// Write a file with workspace boundary enforcement.
@@ -1183,4 +1502,189 @@ mod tests {
        assert!(component_contains_glob("*.rs"));
        assert!(!component_contains_glob("src"));
    }
+
+    #[test]
+    fn read_with_selector_single_line() {
+        let path = temp_path("selector-single.txt");
+        write_file(
+            path.to_string_lossy().as_ref(),
+            "line1\nline2\nline3\nline4\nline5",
+        )
+        .expect("write should succeed");
+
+        let output =
+            super::read_file_with_selector(path.to_string_lossy().as_ref(), None, None, Some("2"))
+                .expect("read with selector should succeed");
+        assert_eq!(output.file.content, "line2");
+        assert_eq!(output.file.start_line, 2);
+        assert_eq!(output.file.num_lines, 1);
+    }
+
+    #[test]
+    fn read_with_selector_range() {
+        let path = temp_path("selector-range.txt");
+        write_file(
+            path.to_string_lossy().as_ref(),
+            "line1\nline2\nline3\nline4\nline5",
+        )
+        .expect("write should succeed");
+
+        let output = super::read_file_with_selector(
+            path.to_string_lossy().as_ref(),
+            None,
+            None,
+            Some("2-4"),
+        )
+        .expect("read with selector should succeed");
+        assert_eq!(output.file.content, "line2\nline3\nline4");
+        assert_eq!(output.file.start_line, 2);
+        assert_eq!(output.file.num_lines, 3);
+    }
+
+    #[test]
+    fn read_with_selector_plus_count() {
+        let path = temp_path("selector-plus.txt");
+        write_file(
+            path.to_string_lossy().as_ref(),
+            "line1\nline2\nline3\nline4\nline5",
+        )
+        .expect("write should succeed");
+
+        let output = super::read_file_with_selector(
+            path.to_string_lossy().as_ref(),
+            None,
+            None,
+            Some("2+2"),
+        )
+        .expect("read with selector should succeed");
+        assert_eq!(output.file.content, "line2\nline3");
+        assert_eq!(output.file.start_line, 2);
+        assert_eq!(output.file.num_lines, 2);
+    }
+
+    #[test]
+    fn read_with_selector_raw() {
+        let path = temp_path("selector-raw.txt");
+        write_file(
+            path.to_string_lossy().as_ref(),
+            "line1\nline2\nline3\nline4\nline5",
+        )
+        .expect("write should succeed");
+
+        let output = super::read_file_with_selector(
+            path.to_string_lossy().as_ref(),
+            None,
+            None,
+            Some("raw"),
+        )
+        .expect("read with selector should succeed");
+        assert_eq!(output.file.content, "line1\nline2\nline3\nline4\nline5");
+        assert_eq!(output.file.start_line, 1);
+        assert_eq!(output.file.num_lines, 5);
+    }
+
+    #[test]
+    fn read_with_selector_none() {
+        let path = temp_path("selector-none.txt");
+        write_file(
+            path.to_string_lossy().as_ref(),
+            "line1\nline2\nline3\nline4\nline5",
+        )
+        .expect("write should succeed");
+
+        let output =
+            super::read_file_with_selector(path.to_string_lossy().as_ref(), None, None, None)
+                .expect("read with selector should succeed");
+        assert_eq!(output.file.content, "line1\nline2\nline3\nline4\nline5");
+        assert_eq!(output.file.start_line, 1);
+        assert_eq!(output.file.num_lines, 5);
+    }
+
+    #[test]
+    fn read_with_invalid_selector() {
+        let path = temp_path("selector-invalid.txt");
+        write_file(
+            path.to_string_lossy().as_ref(),
+            "line1\nline2\nline3\nline4\nline5",
+        )
+        .expect("write should succeed");
+
+        let result = super::read_file_with_selector(
+            path.to_string_lossy().as_ref(),
+            None,
+            None,
+            Some("invalid-selector"),
+        );
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn read_with_selector_conflicts_no_conflicts() {
+        let path = temp_path("conflicts-none.txt");
+        write_file(
+            path.to_string_lossy().as_ref(),
+            "const a = 1;\nconst b = 2;\n",
+        )
+        .expect("write should succeed");
+
+        let output = super::read_file_with_selector(
+            path.to_string_lossy().as_ref(),
+            None,
+            None,
+            Some("conflicts"),
+        )
+        .expect("read with conflicts selector should succeed");
+        assert!(output
+            .file
+            .content
+            .contains("No unresolved git merge conflicts"));
+    }
+
+    #[test]
+    fn read_with_selector_conflicts_two_way() {
+        let path = temp_path("conflicts-two-way.txt");
+        let content = "<<<<<<< A\na-ours\n=======\na-theirs\n>>>>>>> A\nmiddle\n<<<<<<< B\nb-ours\n=======\nb-theirs\n>>>>>>> B\ntail";
+        write_file(path.to_string_lossy().as_ref(), content).expect("write should succeed");
+
+        let output = super::read_file_with_selector(
+            path.to_string_lossy().as_ref(),
+            None,
+            None,
+            Some("conflicts"),
+        )
+        .expect("read with conflicts selector should succeed");
+
+        let text = &output.file.content;
+        // Should report 2 conflicts
+        assert!(text.contains("2 unresolved conflicts"), "text: {}", text);
+        // Should have indices for both blocks
+        assert!(text.contains("#1"), "missing #1: {}", text);
+        assert!(text.contains("#2"), "missing #2: {}", text);
+        // Should have line ranges
+        assert!(text.contains("L1-5"), "missing L1-5: {}", text);
+        assert!(text.contains("L7-11"), "missing L7-11: {}", text);
+    }
+
+    #[test]
+    fn read_with_selector_conflicts_three_way() {
+        let path = temp_path("conflicts-three-way.txt");
+        let content = "head\n<<<<<<< HEAD\nours body\n||||||| common ancestor\nbase body\n=======\ntheirs body\n>>>>>>> feat\ntail";
+        write_file(path.to_string_lossy().as_ref(), content).expect("write should succeed");
+
+        let output = super::read_file_with_selector(
+            path.to_string_lossy().as_ref(),
+            None,
+            None,
+            Some("conflicts"),
+        )
+        .expect("read with conflicts selector should succeed");
+
+        let text = &output.file.content;
+        // Should report 1 conflict
+        assert!(text.contains("1 unresolved conflict"), "text: {}", text);
+        // Should mark as 3-way
+        assert!(text.contains("3-way"), "missing 3-way marker: {}", text);
+        // Should show line range
+        assert!(text.contains("L2-8"), "missing L2-8: {}", text);
+    }
 }
@@ -20,6 +20,7 @@ pub mod green_contract;
 mod hooks;
 mod json;
 mod lane_events;
+pub mod line_range_selector;
 pub mod lsp_client;
 mod mcp;
 mod mcp_client;
@@ -40,6 +41,7 @@ mod report_schema;
 pub mod sandbox;
 mod session;
 pub mod session_control;
+pub mod session_settings;
 pub mod trident;
 pub use session_control::SessionStore;
 mod sse;
@@ -83,11 +85,12 @@ pub use config_validate::{
 pub use conversation::{
    auto_compaction_threshold_from_env, ApiClient, ApiRequest, AssistantEvent, AutoCompactionEvent,
    ConversationRuntime, PromptCacheEvent, RuntimeError, StaticToolExecutor, ToolError,
-    ToolExecutor, TurnSummary,
+    ToolExecutor, TurnInterruptSignal, TurnSummary,
 };
 pub use file_ops::{
    edit_file, edit_file_in_workspace, glob_search, glob_search_in_workspace, grep_search,
-    grep_search_in_workspace, read_file, read_file_in_workspace, write_file,
+    grep_search_in_workspace, read_file, read_file_in_workspace,
+    read_file_in_workspace_with_selector, read_file_with_selector, write_file,
    write_file_in_workspace, EditFileOutput, GlobSearchOutput, GrepSearchInput, GrepSearchOutput,
    ReadFileOutput, StructuredPatchHunk, TextFilePayload, WriteFileOutput,
 };
@@ -177,6 +180,10 @@ pub use session::{
    ContentBlock, ConversationMessage, MessageRole, Session, SessionCompaction, SessionError,
    SessionFork, SessionHeartbeat, SessionLiveness, SessionPromptEntry,
 };
+pub use session_settings::{
+    ConfigHotreloadMonitor, SettingApplicator, SettingCategory, SettingSchema, SettingSchemaRegistry,
+    SettingType, SessionSettings,
+};
 pub use sse::{IncrementalSseParser, SseEvent};
 pub use stale_base::{
    check_base_commit, format_stale_base_warning, read_claw_base_file, resolve_expected_base,
@@ -0,0 +1,347 @@
+/// GJC-compatible line range selector parsing for the read tool.
+///
+/// Supports selector syntax:
+/// - `:50` = start at line 50
+/// - `:50-200` = lines 50-200 inclusive
+/// - `:50+150` = 150 lines starting at 50
+/// - `:50+1` = exactly one line
+/// - `:5-16,960-973` = multiple ranges
+/// - `:raw` = full verbatim
+/// - `:conflicts` = git merge conflicts only
+use std::num::ParseIntError;
+
+/// Parsed line range specification.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum LineRangeSelector {
+    /// Full file verbatim (`:raw`)
+    Raw,
+    /// Git merge conflict sections only (`:conflicts`)
+    Conflicts,
+    /// Line range(s) (`:L-L+N` syntax)
+    Lines(Vec<LineRange>),
+    /// No selector (full file, may be truncated by default budget)
+    None,
+}
+
+/// A single line range, zero-indexed internally but displayed as 1-indexed.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct LineRange {
+    /// Start line (1-indexed, user-facing)
+    pub start_line: usize,
+    /// End line inclusive (1-indexed, user-facing)
+    pub end_line: usize,
+}
+
+impl LineRange {
+    /// Create a new line range (1-indexed).
+    pub fn new(start_line: usize, end_line: usize) -> Self {
+        Self {
+            start_line,
+            end_line,
+        }
+    }
+
+    /// Convert to zero-indexed range for internal use.
+    pub fn zero_indexed(&self) -> (usize, usize) {
+        (
+            self.start_line.saturating_sub(1),
+            self.end_line.saturating_sub(1),
+        )
+    }
+
+    /// Get the number of lines in this range.
+    pub fn len(&self) -> usize {
+        if self.start_line <= self.end_line {
+            self.end_line - self.start_line + 1
+        } else {
+            0
+        }
+    }
+
+    /// Check if this range is valid.
+    pub fn is_valid(&self) -> bool {
+        self.start_line > 0 && self.end_line > 0 && self.start_line <= self.end_line
+    }
+}
+
+/// Parse error types for line range selectors.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ParseError {
+    InvalidFormat(String),
+    InvalidNumber(ParseIntError),
+    InvalidRange(String),
+}
+
+impl std::fmt::Display for ParseError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ParseError::InvalidFormat(msg) => write!(f, "Invalid format: {}", msg),
+            ParseError::InvalidNumber(e) => write!(f, "Invalid number: {}", e),
+            ParseError::InvalidRange(msg) => write!(f, "Invalid range: {}", msg),
+        }
+    }
+}
+
+impl std::error::Error for ParseError {}
+
+impl From<ParseIntError> for ParseError {
+    fn from(e: ParseIntError) -> Self {
+        ParseError::InvalidNumber(e)
+    }
+}
+
+/// Parse a line range selector string.
+///
+/// Examples:
+/// - `"50"` → `LineRangeSelector::Lines(vec![LineRange::new(50, 50)])`
+/// - `"50-200"` → `LineRangeSelector::Lines(vec![LineRange::new(50, 200)])`
+/// - `"50+150"` → `LineRangeSelector::Lines(vec![LineRange::new(50, 199)])`
+/// - `"raw"` → `LineRangeSelector::Raw`
+/// - `"conflicts"` → `LineRangeSelector::Conflicts`
+pub fn parse_selector(selector: &str) -> Result<LineRangeSelector, ParseError> {
+    if selector.is_empty() {
+        return Ok(LineRangeSelector::None);
+    }
+
+    match selector {
+        "raw" => Ok(LineRangeSelector::Raw),
+        "conflicts" => Ok(LineRangeSelector::Conflicts),
+        _ => parse_line_ranges(selector),
+    }
+}
+
+/// Parse comma-separated line ranges.
+fn parse_line_ranges(selector: &str) -> Result<LineRangeSelector, ParseError> {
+    let mut ranges = Vec::new();
+
+    for range_str in selector.split(',') {
+        let range_str = range_str.trim();
+        if range_str.is_empty() {
+            continue;
+        }
+
+        let range = parse_single_range(range_str)?;
+        ranges.push(range);
+    }
+
+    if ranges.is_empty() {
+        Ok(LineRangeSelector::None)
+    } else {
+        // Merge overlapping/adjacent ranges
+        ranges.sort_by_key(|r| r.start_line);
+        let merged = merge_ranges(ranges);
+        Ok(LineRangeSelector::Lines(merged))
+    }
+}
+
+/// Parse a single line range in formats: "50", "50-200", "50+150".
+fn parse_single_range(range_str: &str) -> Result<LineRange, ParseError> {
+    // Try "50+150" format first (start+count)
+    if let Some(plus_idx) = range_str.find('+') {
+        let start_str = &range_str[..plus_idx];
+        let count_str = &range_str[plus_idx + 1..];
+
+        if start_str.is_empty() || count_str.is_empty() {
+            return Err(ParseError::InvalidFormat(range_str.to_string()));
+        }
+
+        let start = start_str.parse::<usize>()?;
+        let count = count_str.parse::<usize>()?;
+
+        if start == 0 || count == 0 {
+            return Err(ParseError::InvalidRange(
+                "Line numbers and counts must be >= 1".to_string(),
+            ));
+        }
+
+        return Ok(LineRange::new(start, start + count - 1));
+    }
+
+    // Try "50-200" format (start-end)
+    if let Some(dash_idx) = range_str.find('-') {
+        // Skip leading dash (negative numbers aren't valid here)
+        if dash_idx == 0 {
+            return Err(ParseError::InvalidFormat(range_str.to_string()));
+        }
+
+        let start_str = &range_str[..dash_idx];
+        let end_str = &range_str[dash_idx + 1..];
+
+        if start_str.is_empty() || end_str.is_empty() {
+            return Err(ParseError::InvalidFormat(range_str.to_string()));
+        }
+
+        let start = start_str.parse::<usize>()?;
+        let end = end_str.parse::<usize>()?;
+
+        if start == 0 || end == 0 {
+            return Err(ParseError::InvalidRange(
+                "Line numbers must be >= 1".to_string(),
+            ));
+        }
+
+        if start > end {
+            return Err(ParseError::InvalidRange(format!(
+                "Start line {} cannot be greater than end line {}",
+                start, end
+            )));
+        }
+
+        return Ok(LineRange::new(start, end));
+    }
+
+    // Try plain "50" format (single line)
+    let line_num = range_str.parse::<usize>()?;
+    if line_num == 0 {
+        return Err(ParseError::InvalidRange(
+            "Line number must be >= 1".to_string(),
+        ));
+    }
+
+    Ok(LineRange::new(line_num, line_num))
+}
+
+/// Merge overlapping and adjacent ranges.
+fn merge_ranges(ranges: Vec<LineRange>) -> Vec<LineRange> {
+    let mut merged: Vec<LineRange> = Vec::new();
+
+    for range in ranges {
+        if let Some(last) = merged.last_mut() {
+            // If ranges overlap or are adjacent, merge them
+            if range.start_line <= last.end_line + 1 {
+                last.end_line = last.end_line.max(range.end_line);
+            } else {
+                merged.push(range);
+            }
+        } else {
+            merged.push(range);
+        }
+    }
+
+    merged
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_raw() {
+        assert_eq!(parse_selector("raw").unwrap(), LineRangeSelector::Raw);
+    }
+
+    #[test]
+    fn test_parse_conflicts() {
+        assert_eq!(
+            parse_selector("conflicts").unwrap(),
+            LineRangeSelector::Conflicts
+        );
+    }
+
+    #[test]
+    fn test_parse_single_line() {
+        match parse_selector("50").unwrap() {
+            LineRangeSelector::Lines(ranges) => {
+                assert_eq!(ranges.len(), 1);
+                assert_eq!(ranges[0].start_line, 50);
+                assert_eq!(ranges[0].end_line, 50);
+            }
+            _ => panic!("Expected Lines variant"),
+        }
+    }
+
+    #[test]
+    fn test_parse_range_start_dash_end() {
+        match parse_selector("50-200").unwrap() {
+            LineRangeSelector::Lines(ranges) => {
+                assert_eq!(ranges.len(), 1);
+                assert_eq!(ranges[0].start_line, 50);
+                assert_eq!(ranges[0].end_line, 200);
+            }
+            _ => panic!("Expected Lines variant"),
+        }
+    }
+
+    #[test]
+    fn test_parse_range_start_plus_count() {
+        match parse_selector("50+150").unwrap() {
+            LineRangeSelector::Lines(ranges) => {
+                assert_eq!(ranges.len(), 1);
+                assert_eq!(ranges[0].start_line, 50);
+                assert_eq!(ranges[0].end_line, 199);
+            }
+            _ => panic!("Expected Lines variant"),
+        }
+    }
+
+    #[test]
+    fn test_parse_multiple_ranges() {
+        match parse_selector("5-16,960-973").unwrap() {
+            LineRangeSelector::Lines(ranges) => {
+                assert_eq!(ranges.len(), 2);
+                assert_eq!(ranges[0].start_line, 5);
+                assert_eq!(ranges[0].end_line, 16);
+                assert_eq!(ranges[1].start_line, 960);
+                assert_eq!(ranges[1].end_line, 973);
+            }
+            _ => panic!("Expected Lines variant"),
+        }
+    }
+
+    #[test]
+    fn test_merge_overlapping_ranges() {
+        // "5-16,10-20" should merge into "5-20"
+        match parse_selector("5-16,10-20").unwrap() {
+            LineRangeSelector::Lines(ranges) => {
+                assert_eq!(ranges.len(), 1);
+                assert_eq!(ranges[0].start_line, 5);
+                assert_eq!(ranges[0].end_line, 20);
+            }
+            _ => panic!("Expected Lines variant"),
+        }
+    }
+
+    #[test]
+    fn test_merge_adjacent_ranges() {
+        // "5-16,17-20" should merge into "5-20"
+        match parse_selector("5-16,17-20").unwrap() {
+            LineRangeSelector::Lines(ranges) => {
+                assert_eq!(ranges.len(), 1);
+                assert_eq!(ranges[0].start_line, 5);
+                assert_eq!(ranges[0].end_line, 20);
+            }
+            _ => panic!("Expected Lines variant"),
+        }
+    }
+
+    #[test]
+    fn test_invalid_range_start_greater_than_end() {
+        let result = parse_selector("200-50");
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_invalid_zero_line() {
+        let result = parse_selector("0");
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_empty_selector() {
+        assert_eq!(parse_selector("").unwrap(), LineRangeSelector::None);
+    }
+
+    #[test]
+    fn test_line_range_zero_indexed() {
+        let range = LineRange::new(50, 200);
+        let (start, end) = range.zero_indexed();
+        assert_eq!(start, 49);
+        assert_eq!(end, 199);
+    }
+
+    #[test]
+    fn test_line_range_len() {
+        assert_eq!(LineRange::new(50, 200).len(), 151);
+        assert_eq!(LineRange::new(50, 50).len(), 1);
+    }
+}
@@ -34,6 +34,9 @@ pub enum WorkerStatus {
    ToolPermissionRequired,
    ReadyForPrompt,
    Running,
+    /// The user stopped the turn mid-run (e.g. Esc or Ctrl+C); the worker
+    /// is back at the prompt with the session intact.
+    Interrupted,
    Finished,
    Failed,
 }
@@ -46,6 +49,7 @@ impl std::fmt::Display for WorkerStatus {
            Self::ToolPermissionRequired => write!(f, "tool_permission_required"),
            Self::ReadyForPrompt => write!(f, "ready_for_prompt"),
            Self::Running => write!(f, "running"),
+            Self::Interrupted => write!(f, "interrupted"),
            Self::Finished => write!(f, "finished"),
            Self::Failed => write!(f, "failed"),
        }
@@ -82,6 +86,7 @@ pub enum WorkerEventKind {
    PromptMisdelivery,
    PromptReplayArmed,
    Running,
+    Interrupted,
    Restarted,
    Finished,
    Failed,
@@ -1461,6 +1466,23 @@ mod tests {
    use std::fs;
    use std::process::Command;

+    #[test]
+    fn interrupted_status_serializes_and_displays_as_snake_case() {
+        assert_eq!(WorkerStatus::Interrupted.to_string(), "interrupted");
+        assert_eq!(
+            serde_json::to_string(&WorkerStatus::Interrupted).expect("should serialize"),
+            "\"interrupted\""
+        );
+        assert_eq!(
+            serde_json::from_str::<WorkerStatus>("\"interrupted\"").expect("should deserialize"),
+            WorkerStatus::Interrupted
+        );
+        assert_eq!(
+            serde_json::to_string(&WorkerEventKind::Interrupted).expect("should serialize"),
+            "\"interrupted\""
+        );
+    }
+
    #[test]
    fn allowlisted_trust_prompt_auto_resolves_then_reaches_ready_state() {
        let registry = WorkerRegistry::new();
@@ -24,6 +24,8 @@ tokio = { version = "1", features = ["rt-multi-thread", "signal", "time"] }
 tools = { path = "../tools" }
 log = "0.4"

+[target.'cfg(unix)'.dependencies]
+nix = { version = "0.29", features = ["term", "poll"] }

 [lints]
 workspace = true
@@ -0,0 +1,280 @@
+//! Esc-key interruption for running turns.
+//!
+//! While a turn runs, the main thread is blocked inside the conversation
+//! loop, so rustyline is not reading the keyboard. This module spawns a
+//! listener thread that switches stdin to a minimal non-canonical mode
+//! (line buffering and echo off; signal handling and output processing
+//! stay enabled, unlike full raw mode) and watches for a lone Escape
+//! byte. When one arrives it trips the shared [`TurnInterruptSignal`],
+//! which the conversation loop and the streaming API client poll to wind
+//! the turn down gracefully.
+//!
+//! Permission prompts read whole lines from stdin mid-turn, so stdin
+//! ownership is coordinated through [`StdinPromptGate`]: while a prompt
+//! holds a lease, the listener restores canonical mode and stops
+//! consuming bytes.
+
+use std::io::IsTerminal;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex, PoisonError};
+use std::thread::JoinHandle;
+
+use runtime::TurnInterruptSignal;
+
+/// Terminal-mode bookkeeping guarded by the gate mutex. `saved` holds the
+/// canonical-mode termios while non-canonical mode is active.
+#[derive(Default)]
+struct TtyMode {
+    #[cfg(unix)]
+    saved: Option<nix::sys::termios::Termios>,
+}
+
+#[derive(Default)]
+struct GateState {
+    /// True while a permission prompt owns stdin.
+    busy: AtomicBool,
+    /// Tells the listener thread to exit at the end of the turn.
+    stop: AtomicBool,
+    /// Serializes stdin reads and terminal-mode flips.
+    mode: Mutex<TtyMode>,
+}
+
+/// Classification of one chunk of bytes read from the terminal.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum EscClassification {
+    /// A bare ESC byte: the user pressed the Escape key.
+    LoneEscape,
+    /// ESC followed by more bytes: the prefix of a terminal escape
+    /// sequence such as an arrow or function key.
+    EscapeSequence,
+    /// Anything else (regular type-ahead, control characters, ...).
+    Other,
+}
+
+#[cfg_attr(not(unix), allow(dead_code))]
+fn classify_escape_chunk(bytes: &[u8]) -> EscClassification {
+    match bytes {
+        [0x1b] => EscClassification::LoneEscape,
+        [0x1b, ..] => EscClassification::EscapeSequence,
+        _ => EscClassification::Other,
+    }
+}
+
+/// Hands exclusive stdin ownership to interactive prompts while the
+/// Esc listener is running.
+#[derive(Clone)]
+pub struct StdinPromptGate {
+    shared: Arc<GateState>,
+}
+
+impl StdinPromptGate {
+    /// Takes stdin away from the Esc listener for the lifetime of the
+    /// returned lease: the terminal returns to canonical mode so a
+    /// line-based prompt (e.g. the permission approval prompt) behaves
+    /// normally. Listening resumes when the lease is dropped.
+    pub fn lease(&self) -> StdinPromptLease<'_> {
+        self.shared.busy.store(true, Ordering::SeqCst);
+        // Wait for the listener's current poll cycle to release the
+        // terminal, then restore canonical mode for line input.
+        #[allow(unused_mut)]
+        let mut mode = self
+            .shared
+            .mode
+            .lock()
+            .unwrap_or_else(PoisonError::into_inner);
+        #[cfg(unix)]
+        tty::restore(&mut mode);
+        drop(mode);
+        StdinPromptLease {
+            shared: &self.shared,
+        }
+    }
+}
+
+/// RAII lease returned by [`StdinPromptGate::lease`].
+pub struct StdinPromptLease<'a> {
+    shared: &'a GateState,
+}
+
+impl Drop for StdinPromptLease<'_> {
+    fn drop(&mut self) {
+        self.shared.busy.store(false, Ordering::SeqCst);
+    }
+}
+
+/// Background listener that maps a lone Esc keypress to
+/// [`TurnInterruptSignal::interrupt`].
+pub struct EscapeInterruptMonitor {
+    shared: Arc<GateState>,
+    join_handle: Option<JoinHandle<()>>,
+}
+
+impl EscapeInterruptMonitor {
+    /// Spawns the listener for the duration of one turn. Returns `None`
+    /// when stdin is not an interactive terminal or the platform does not
+    /// support terminal-mode switching; Ctrl+C interruption still works
+    /// in those cases.
+    pub fn spawn(signal: TurnInterruptSignal) -> Option<(Self, StdinPromptGate)> {
+        if !std::io::stdin().is_terminal() {
+            return None;
+        }
+
+        #[cfg(not(unix))]
+        {
+            let _ = signal;
+            None
+        }
+
+        #[cfg(unix)]
+        {
+            let shared = Arc::new(GateState::default());
+            let thread_shared = Arc::clone(&shared);
+            let join_handle = std::thread::spawn(move || listener_loop(&thread_shared, &signal));
+            let gate = StdinPromptGate {
+                shared: Arc::clone(&shared),
+            };
+            Some((
+                Self {
+                    shared,
+                    join_handle: Some(join_handle),
+                },
+                gate,
+            ))
+        }
+    }
+
+    /// Stops the listener and restores the terminal before control
+    /// returns to the line editor.
+    pub fn stop(mut self) {
+        self.shared.stop.store(true, Ordering::SeqCst);
+        if let Some(join_handle) = self.join_handle.take() {
+            let _ = join_handle.join();
+        }
+    }
+}
+
+#[cfg(unix)]
+fn listener_loop(shared: &GateState, signal: &TurnInterruptSignal) {
+    let mut buffer = [0u8; 64];
+
+    while !shared.stop.load(Ordering::SeqCst) {
+        if shared.busy.load(Ordering::SeqCst) {
+            std::thread::sleep(std::time::Duration::from_millis(25));
+            continue;
+        }
+
+        let mut mode = shared.mode.lock().unwrap_or_else(PoisonError::into_inner);
+        if shared.busy.load(Ordering::SeqCst) || shared.stop.load(Ordering::SeqCst) {
+            continue;
+        }
+        if !tty::enable_noncanonical(&mut mode) {
+            // Terminal refused the mode switch; Esc support is
+            // unavailable for this turn but Ctrl+C still works.
+            return;
+        }
+        if !tty::wait_readable(100) {
+            continue;
+        }
+
+        let count = tty::read_pending(&mut buffer);
+        if classify_escape_chunk(&buffer[..count]) == EscClassification::LoneEscape {
+            // A slow terminal may split an escape sequence across reads;
+            // only treat ESC as the Esc key when nothing follows it.
+            if tty::wait_readable(50) {
+                let _ = tty::read_pending(&mut buffer);
+                continue;
+            }
+            signal.interrupt();
+        }
+        // Other bytes are intentionally swallowed: type-ahead is not
+        // preserved while a turn is running.
+    }
+
+    let mut mode = shared.mode.lock().unwrap_or_else(PoisonError::into_inner);
+    tty::restore(&mut mode);
+}
+
+#[cfg(unix)]
+mod tty {
+    use std::os::fd::{AsFd, AsRawFd};
+
+    use nix::poll::{poll, PollFd, PollFlags, PollTimeout};
+    use nix::sys::termios::{self, LocalFlags, SetArg, SpecialCharacterIndices};
+
+    use super::TtyMode;
+
+    /// Disables line buffering and echo while leaving signal generation
+    /// (ISIG) and output post-processing (OPOST) untouched, so Ctrl+C and
+    /// streamed output keep working. No-op when already active.
+    pub(super) fn enable_noncanonical(mode: &mut TtyMode) -> bool {
+        if mode.saved.is_some() {
+            return true;
+        }
+        let stdin = std::io::stdin();
+        let Ok(saved) = termios::tcgetattr(&stdin) else {
+            return false;
+        };
+        let mut noncanonical = saved.clone();
+        noncanonical.local_flags &= !(LocalFlags::ICANON | LocalFlags::ECHO);
+        noncanonical.control_chars[SpecialCharacterIndices::VMIN as usize] = 0;
+        noncanonical.control_chars[SpecialCharacterIndices::VTIME as usize] = 0;
+        if termios::tcsetattr(&stdin, SetArg::TCSANOW, &noncanonical).is_err() {
+            return false;
+        }
+        mode.saved = Some(saved);
+        true
+    }
+
+    pub(super) fn restore(mode: &mut TtyMode) {
+        if let Some(saved) = mode.saved.take() {
+            let _ = termios::tcsetattr(std::io::stdin(), SetArg::TCSANOW, &saved);
+        }
+    }
+
+    pub(super) fn wait_readable(timeout_ms: u16) -> bool {
+        let stdin = std::io::stdin();
+        let mut fds = [PollFd::new(stdin.as_fd(), PollFlags::POLLIN)];
+        matches!(poll(&mut fds, PollTimeout::from(timeout_ms)), Ok(ready) if ready > 0)
+            && fds[0]
+                .revents()
+                .is_some_and(|revents| revents.contains(PollFlags::POLLIN))
+    }
+
+    pub(super) fn read_pending(buffer: &mut [u8]) -> usize {
+        nix::unistd::read(std::io::stdin().as_raw_fd(), buffer).unwrap_or(0)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{classify_escape_chunk, EscClassification};
+
+    #[test]
+    fn lone_escape_byte_is_the_esc_key() {
+        assert_eq!(
+            classify_escape_chunk(&[0x1b]),
+            EscClassification::LoneEscape
+        );
+    }
+
+    #[test]
+    fn escape_followed_by_more_bytes_is_a_sequence() {
+        // Up arrow: ESC [ A
+        assert_eq!(
+            classify_escape_chunk(&[0x1b, 0x5b, 0x41]),
+            EscClassification::EscapeSequence
+        );
+        // Alt+f style: ESC f
+        assert_eq!(
+            classify_escape_chunk(&[0x1b, b'f']),
+            EscClassification::EscapeSequence
+        );
+    }
+
+    #[test]
+    fn regular_bytes_are_ignored() {
+        assert_eq!(classify_escape_chunk(b"hello"), EscClassification::Other);
+        assert_eq!(classify_escape_chunk(&[]), EscClassification::Other);
+        assert_eq!(classify_escape_chunk(&[0x03]), EscClassification::Other);
+    }
+}
@@ -16,6 +16,7 @@
 )]
 mod init;
 mod input;
+mod interrupt;
 mod render;
 mod setup_wizard;

@@ -1035,6 +1036,8 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
            output_format,
        } => print_system_prompt(cwd, date, &model, output_format)?,
        CliAction::Version { output_format } => print_version(output_format)?,
+        CliAction::Tools { output_format } => print_tools(output_format)?,
+        CliAction::Info { output_format } => print_info(output_format)?,
        CliAction::ResumeSession {
            session_path,
            commands,
@@ -1196,6 +1199,12 @@ enum CliAction {
    Version {
        output_format: CliOutputFormat,
    },
+    Tools {
+        output_format: CliOutputFormat,
+    },
+    Info {
+        output_format: CliOutputFormat,
+    },
    SessionList {
        output_format: CliOutputFormat,
    },
@@ -2598,6 +2607,8 @@ fn parse_direct_slash_cli_action(
        Ok(Some(SlashCommand::Sandbox)) => Ok(CliAction::Sandbox { output_format }),
        Ok(Some(SlashCommand::Diff)) => Ok(CliAction::Diff { output_format }),
        Ok(Some(SlashCommand::Version)) => Ok(CliAction::Version { output_format }),
+        Ok(Some(SlashCommand::Tools)) => Ok(CliAction::Tools { output_format }),
+        Ok(Some(SlashCommand::Info)) => Ok(CliAction::Info { output_format }),
        Ok(Some(SlashCommand::Doctor)) => Ok(CliAction::Doctor {
            output_format,
            permission_mode,
@@ -5077,6 +5088,84 @@ fn version_json_value() -> serde_json::Value {
    })
 }

+fn print_tools(output_format: CliOutputFormat) -> Result<(), Box<dyn std::error::Error>> {
+    let specs = mvp_tool_specs();
+    match output_format {
+        CliOutputFormat::Text => {
+            println!("Available tools ({}):", specs.len());
+            for spec in &specs {
+                println!("  {}\n    {}", spec.name, spec.description);
+            }
+        }
+        CliOutputFormat::Json => {
+            let tools: Vec<_> = specs
+                .into_iter()
+                .map(|spec| {
+                    json!({
+                        "name": spec.name,
+                        "description": spec.description,
+                    })
+                })
+                .collect();
+            println!(
+                "{}",
+                serde_json::to_string_pretty(&json!({
+                    "kind": "tools",
+                    "action": "list",
+                    "status": "ok",
+                    "tools": tools,
+                    "count": tools.len(),
+                }))?
+            );
+        }
+    }
+    Ok(())
+}
+
+fn print_info(output_format: CliOutputFormat) -> Result<(), Box<dyn std::error::Error>> {
+    let cwd = env::current_dir().ok();
+    let binary_provenance = binary_provenance_for(cwd.as_deref());
+    match output_format {
+        CliOutputFormat::Text => {
+            println!("claw-code runtime information:");
+            println!("  Version: {}", VERSION);
+            if let Some(sha) = &binary_provenance.git_sha_short {
+                println!("  Git SHA: {}", sha);
+            }
+            if let Some(branch) = &binary_provenance.branch {
+                println!("  Branch: {}", branch);
+            }
+            println!("  Commit date: {}", binary_provenance.commit_date);
+            println!("  Rustc version: {}", binary_provenance.rustc_version);
+            if let Some(target) = &binary_provenance.target {
+                println!("  Target: {}", target);
+            }
+            if let Some(path) = binary_provenance.executable_path {
+                println!("  Executable: {}", path);
+            }
+        }
+        CliOutputFormat::Json => {
+            println!(
+                "{}",
+                serde_json::to_string_pretty(&json!({
+                    "kind": "info",
+                    "action": "show",
+                    "status": "ok",
+                    "version": VERSION,
+                    "git_sha": binary_provenance.git_sha,
+                    "git_sha_short": binary_provenance.git_sha_short,
+                    "branch": binary_provenance.branch,
+                    "commit_date": binary_provenance.commit_date,
+                    "rustc_version": binary_provenance.rustc_version,
+                    "target": binary_provenance.target,
+                    "executable_path": binary_provenance.executable_path,
+                }))?
+            );
+        }
+    }
+    Ok(())
+}
+
 #[allow(clippy::too_many_lines)]
 fn resume_session(session_path: &Path, commands: &[String], output_format: CliOutputFormat) {
    let session_reference = session_path.display().to_string();
@@ -6785,6 +6874,56 @@ fn run_resume_command(
            message: Some(render_version_report()),
            json: Some(version_json_value()),
        }),
+        SlashCommand::Tools => {
+            let specs = mvp_tool_specs();
+            let tool_count = specs.len();
+            let tools_text = specs
+                .iter()
+                .map(|spec| format!("  {}\n    {}", spec.name, spec.description))
+                .collect::<Vec<_>>()
+                .join("\n");
+            let message = format!("Available tools ({}):\n{}", tool_count, tools_text);
+            let json_tools: Vec<_> = specs
+                .into_iter()
+                .map(|spec| serde_json::json!({ "name": spec.name, "description": spec.description }))
+                .collect();
+            Ok(ResumeCommandOutcome {
+                session: session.clone(),
+                message: Some(message),
+                json: Some(serde_json::json!({
+                    "kind": "tools",
+                    "action": "list",
+                    "status": "ok",
+                    "tools": json_tools,
+                    "count": tool_count,
+                })),
+            })
+        }
+        SlashCommand::Info => {
+            let cwd = env::current_dir().ok();
+            let binary_provenance = binary_provenance_for(cwd.as_deref());
+            let message = format!(
+                "claw-code runtime information:\n  Version: {}\n  Git SHA: {}\n  Rustc: {}\n  Target: {}",
+                VERSION,
+                binary_provenance.git_sha_short.as_deref().unwrap_or("unknown"),
+                binary_provenance.rustc_version,
+                binary_provenance.target.as_deref().unwrap_or("unknown")
+            );
+            Ok(ResumeCommandOutcome {
+                session: session.clone(),
+                message: Some(message),
+                json: Some(serde_json::json!({
+                    "kind": "info",
+                    "action": "show",
+                    "status": "ok",
+                    "version": VERSION,
+                    "git_sha": binary_provenance.git_sha,
+                    "git_sha_short": binary_provenance.git_sha_short,
+                    "rustc_version": binary_provenance.rustc_version,
+                    "target": binary_provenance.target,
+                })),
+            })
+        }
        SlashCommand::Export { path } => {
            let export_path = resolve_export_path(path.as_deref(), session)?;
            fs::write(&export_path, render_export_text(session))?;
@@ -7298,6 +7437,18 @@ impl BuiltRuntime {
        self
    }

+    fn with_turn_interrupt_signal(mut self, signal: runtime::TurnInterruptSignal) -> Self {
+        let mut runtime = self
+            .runtime
+            .take()
+            .expect("runtime should exist before installing turn interrupt signal");
+        runtime
+            .api_client_mut()
+            .set_turn_interrupt_signal(signal.clone());
+        self.runtime = Some(runtime.with_turn_interrupt_signal(signal));
+        self
+    }
+
    fn shutdown_plugins(&mut self) -> Result<(), Box<dyn std::error::Error>> {
        if self.plugins_active {
            self.plugin_registry.shutdown()?;
@@ -7680,7 +7831,10 @@ struct HookAbortMonitor {
 }

 impl HookAbortMonitor {
-    fn spawn(abort_signal: runtime::HookAbortSignal) -> Self {
+    fn spawn(
+        abort_signal: runtime::HookAbortSignal,
+        turn_interrupt_signal: runtime::TurnInterruptSignal,
+    ) -> Self {
        Self::spawn_with_waiter(abort_signal, move |stop_rx, abort_signal| {
            let Ok(runtime) = tokio::runtime::Builder::new_current_thread()
                .enable_all()
@@ -7697,7 +7851,11 @@ impl HookAbortMonitor {
                tokio::select! {
                    result = tokio::signal::ctrl_c() => {
                        if result.is_ok() {
+                            // Ctrl+C stops the whole turn, not just running
+                            // hooks: the conversation loop and the streaming
+                            // client both poll the turn interrupt signal.
                            abort_signal.abort();
+                            turn_interrupt_signal.interrupt();
                        }
                    }
                    _ = wait_for_stop => {}
@@ -7803,7 +7961,7 @@ impl LiveCli {
  \x1b[2mDirectory\x1b[0m        {}\n\
  \x1b[2mSession\x1b[0m          {}\n\
  \x1b[2mAuto-save\x1b[0m        {}\n\n\
-  Type \x1b[1m/help\x1b[0m for commands · \x1b[1m/status\x1b[0m for live context · \x1b[2m/resume latest\x1b[0m jumps back to the newest session · \x1b[1m/diff\x1b[0m then \x1b[1m/commit\x1b[0m to ship · \x1b[2mTab\x1b[0m for workflow completions · \x1b[2mShift+Enter\x1b[0m for newline",
+  Type \x1b[1m/help\x1b[0m for commands · \x1b[1m/status\x1b[0m for live context · \x1b[2m/resume latest\x1b[0m jumps back to the newest session · \x1b[1m/diff\x1b[0m then \x1b[1m/commit\x1b[0m to ship · \x1b[2mTab\x1b[0m for workflow completions · \x1b[2mShift+Enter\x1b[0m for newline · \x1b[2mEsc\x1b[0m interrupts a running turn",
            self.model,
            self.permission_mode.as_str(),
            git_branch,
@@ -7829,8 +7987,12 @@ impl LiveCli {
        &self,
        emit_output: bool,
        terminal_tail: TerminalTail,
-    ) -> Result<(BuiltRuntime, HookAbortMonitor), Box<dyn std::error::Error>> {
+    ) -> Result<
+        (BuiltRuntime, HookAbortMonitor, runtime::TurnInterruptSignal),
+        Box<dyn std::error::Error>,
+    > {
        let hook_abort_signal = runtime::HookAbortSignal::new();
+        let turn_interrupt_signal = runtime::TurnInterruptSignal::new();
        let runtime = build_runtime(
            self.runtime.session().clone(),
            &self.session.id,
@@ -7843,10 +8005,12 @@ impl LiveCli {
            self.permission_mode,
            None,
        )?
-        .with_hook_abort_signal(hook_abort_signal.clone());
-        let hook_abort_monitor = HookAbortMonitor::spawn(hook_abort_signal);
+        .with_hook_abort_signal(hook_abort_signal.clone())
+        .with_turn_interrupt_signal(turn_interrupt_signal.clone());
+        let hook_abort_monitor =
+            HookAbortMonitor::spawn(hook_abort_signal, turn_interrupt_signal.clone());

-        Ok((runtime, hook_abort_monitor))
+        Ok((runtime, hook_abort_monitor, turn_interrupt_signal))
    }

    fn replace_runtime(&mut self, runtime: BuiltRuntime) -> Result<(), Box<dyn std::error::Error>> {
@@ -7857,8 +8021,16 @@ impl LiveCli {

    fn run_turn(&mut self, input: &str) -> Result<(), Box<dyn std::error::Error>> {
        let terminal_tail = TerminalTail::new();
-        let (mut runtime, hook_abort_monitor) =
+        let (mut runtime, hook_abort_monitor, turn_interrupt_signal) =
            self.prepare_turn_runtime(true, terminal_tail.clone())?;
+        let mut permission_prompter = CliPermissionPrompter::new(self.permission_mode);
+        let mut escape_monitor = None;
+        if let Some((monitor, stdin_gate)) =
+            interrupt::EscapeInterruptMonitor::spawn(turn_interrupt_signal)
+        {
+            permission_prompter = permission_prompter.with_stdin_gate(stdin_gate);
+            escape_monitor = Some(monitor);
+        }
        let mut spinner = Spinner::new();
        let mut stdout = io::stdout();
        // The animated frame is cursor control: it saves the cursor, rewrites the
@@ -7869,13 +8041,19 @@ impl LiveCli {
        // emitted either way.
        if io::stdout().is_terminal() {
            spinner.tick(
-                "🦀 Thinking...",
+                if escape_monitor.is_some() {
+                    "🦀 Thinking... (esc to interrupt)"
+                } else {
+                    "🦀 Thinking..."
+                },
                TerminalRenderer::new().color_theme(),
                &mut stdout,
-            )?;
+            )?
        }
-        let mut permission_prompter = CliPermissionPrompter::new(self.permission_mode);
        let result = runtime.run_turn(input, Some(&mut permission_prompter));
+        if let Some(monitor) = escape_monitor {
+            monitor.stop();
+        }
        hook_abort_monitor.stop();
        match result {
            Ok(summary) => {
@@ -7892,7 +8070,11 @@ impl LiveCli {
                    println!();
                }
                spinner.finish(
-                    "✨ Done",
+                    if summary.interrupted {
+                        "⏹ Interrupted"
+                    } else {
+                        "✨ Done"
+                    },
                    TerminalRenderer::new().color_theme(),
                    &mut stdout,
                )?;
@@ -8026,7 +8208,7 @@ impl LiveCli {
                        *self.runtime.session_mut() = result.compacted_session.clone();

                        // Build a new runtime with the compacted session and retry
-                        let (mut new_runtime, hook_abort_monitor) =
+                        let (mut new_runtime, hook_abort_monitor, _turn_interrupt_signal) =
                            self.prepare_turn_runtime(true, terminal_tail.clone())?;
                        drop(hook_abort_monitor);

@@ -8119,7 +8301,7 @@ impl LiveCli {
    }

    fn run_prompt_compact(&mut self, input: &str) -> Result<(), Box<dyn std::error::Error>> {
-        let (mut runtime, hook_abort_monitor) =
+        let (mut runtime, hook_abort_monitor, _turn_interrupt_signal) =
            self.prepare_turn_runtime(false, TerminalTail::new())?;
        let mut permission_prompter = CliPermissionPrompter::new(self.permission_mode);
        let result = runtime.run_turn(input, Some(&mut permission_prompter));
@@ -8133,7 +8315,7 @@ impl LiveCli {
    }

    fn run_prompt_compact_json(&mut self, input: &str) -> Result<(), Box<dyn std::error::Error>> {
-        let (mut runtime, hook_abort_monitor) =
+        let (mut runtime, hook_abort_monitor, _turn_interrupt_signal) =
            self.prepare_turn_runtime(false, TerminalTail::new())?;
        let mut permission_prompter = CliPermissionPrompter::new(self.permission_mode);
        let result = runtime.run_turn(input, Some(&mut permission_prompter));
@@ -8159,7 +8341,7 @@ impl LiveCli {
    }

    fn run_prompt_json(&mut self, input: &str) -> Result<(), Box<dyn std::error::Error>> {
-        let (mut runtime, hook_abort_monitor) =
+        let (mut runtime, hook_abort_monitor, _turn_interrupt_signal) =
            self.prepare_turn_runtime(false, TerminalTail::new())?;
        let mut permission_prompter = CliPermissionPrompter::new(self.permission_mode);
        let result = runtime.run_turn(input, Some(&mut permission_prompter));
@@ -8286,6 +8468,18 @@ impl LiveCli {
                Self::print_version(CliOutputFormat::Text);
                false
            }
+            SlashCommand::Tools => {
+                if let Err(error) = print_tools(CliOutputFormat::Text) {
+                    eprintln!("Tools: {error}");
+                }
+                false
+            }
+            SlashCommand::Info => {
+                if let Err(error) = print_info(CliOutputFormat::Text) {
+                    eprintln!("Info: {error}");
+                }
+                false
+            }
            SlashCommand::Export { path } => {
                self.export_session(path.as_deref())?;
                false
@@ -9722,6 +9916,7 @@ fn render_repl_help() -> String {
        "  Ctrl-R               Reverse-search prompt history".to_string(),
        "  Tab                  Complete commands, modes, and recent sessions".to_string(),
        "  Ctrl-C               Clear input (or exit on empty prompt)".to_string(),
+        "  Esc                  Interrupt the running turn".to_string(),
        "  Shift+Enter/Ctrl+J   Insert a newline".to_string(),
        "  Auto-save            .claw/sessions/<workspace-fingerprint>/<session-id>.jsonl"
            .to_string(),
@@ -12774,11 +12969,20 @@ impl runtime::HookProgressReporter for CliHookProgressReporter {

 struct CliPermissionPrompter {
    current_mode: PermissionMode,
+    stdin_gate: Option<interrupt::StdinPromptGate>,
 }

 impl CliPermissionPrompter {
    fn new(current_mode: PermissionMode) -> Self {
-        Self { current_mode }
+        Self {
+            current_mode,
+            stdin_gate: None,
+        }
+    }
+
+    fn with_stdin_gate(mut self, stdin_gate: interrupt::StdinPromptGate) -> Self {
+        self.stdin_gate = Some(stdin_gate);
+        self
    }
 }

@@ -12787,6 +12991,12 @@ impl runtime::PermissionPrompter for CliPermissionPrompter {
        &mut self,
        request: &runtime::PermissionRequest,
    ) -> runtime::PermissionPromptDecision {
+        // Take stdin back from the Esc listener (restoring canonical
+        // mode) for the duration of this line-based prompt.
+        let _stdin_lease = self
+            .stdin_gate
+            .as_ref()
+            .map(interrupt::StdinPromptGate::lease);
        println!();
        println!("Permission approval required");
        println!("  Tool             {}", request.tool_name);
@@ -12910,6 +13120,7 @@ fn provider_config_from_runtime(
        "anthropic" => api::ProviderConfigKind::Anthropic,
        "xai" => api::ProviderConfigKind::Xai,
        "openai" => api::ProviderConfigKind::OpenAi,
+        "custom-openai" => api::ProviderConfigKind::CustomOpenAi,
        "dashscope" => api::ProviderConfigKind::DashScope,
        other => {
            return Err(format!(
@@ -12947,6 +13158,7 @@ fn explicit_provider_kind_for_model(
        Some("anthropic") => Some(api::ProviderConfigKind::Anthropic),
        Some("xai") => Some(api::ProviderConfigKind::Xai),
        Some("openai") | Some("local") => Some(api::ProviderConfigKind::OpenAi),
+        Some("custom-openai") => Some(api::ProviderConfigKind::CustomOpenAi),
        Some("dashscope") | Some("qwen") | Some("kimi") => Some(api::ProviderConfigKind::DashScope),
        _ => {
            let lower = resolved_model.to_ascii_lowercase();
@@ -12984,6 +13196,7 @@ struct AnthropicRuntimeClient {
    tool_registry: GlobalToolRegistry,
    progress_reporter: Option<InternalPromptProgressReporter>,
    reasoning_effort: Option<String>,
+    turn_interrupt_signal: Option<runtime::TurnInterruptSignal>,
 }

 impl AnthropicRuntimeClient {
@@ -13069,12 +13282,17 @@ impl AnthropicRuntimeClient {
            tool_registry,
            progress_reporter,
            reasoning_effort: None,
+            turn_interrupt_signal: None,
        })
    }

    fn set_reasoning_effort(&mut self, effort: Option<String>) {
        self.reasoning_effort = effort;
    }
+
+    fn set_turn_interrupt_signal(&mut self, signal: runtime::TurnInterruptSignal) {
+        self.turn_interrupt_signal = Some(signal);
+    }
 }

 fn resolve_cli_auth_source() -> Result<AuthSource, Box<dyn std::error::Error>> {
@@ -13118,30 +13336,50 @@ impl ApiClient for AnthropicRuntimeClient {
        };

        self.runtime.block_on(async {
-            // When resuming after tool execution, apply a stall timeout on the
-            // first stream event.  If the model does not respond within the
-            // deadline we drop the stalled connection and re-send the request as
-            // a continuation nudge (one retry only).
-            let max_attempts: usize = if is_post_tool { 2 } else { 1 };
+            let request_loop = async {
+                // When resuming after tool execution, apply a stall timeout on the
+                // first stream event.  If the model does not respond within the
+                // deadline we drop the stalled connection and re-send the request as
+                // a continuation nudge (one retry only).
+                let max_attempts: usize = if is_post_tool { 2 } else { 1 };

-            for attempt in 1..=max_attempts {
-                let result = self
-                    .consume_stream(&message_request, is_post_tool && attempt == 1)
-                    .await;
-                match result {
-                    Ok(events) => return Ok(events),
-                    Err(error)
-                        if error.to_string().contains("post-tool stall")
-                            && attempt < max_attempts =>
-                    {
-                        // Stalled after tool completion — nudge the model by
-                        // re-sending the same request.
+                for attempt in 1..=max_attempts {
+                    let result = self
+                        .consume_stream(&message_request, is_post_tool && attempt == 1)
+                        .await;
+                    match result {
+                        Ok(events) => return Ok(events),
+                        Err(error)
+                            if error.to_string().contains("post-tool stall")
+                                && attempt < max_attempts =>
+                        {
+                            // Stalled after tool completion — nudge the model by
+                            // re-sending the same request.
+                        }
+                        Err(error) => return Err(error),
                    }
-                    Err(error) => return Err(error),
+                }
+
+                Err(RuntimeError::new("post-tool continuation nudge exhausted"))
+            };
+
+            let Some(interrupt) = self.turn_interrupt_signal.clone() else {
+                return request_loop.await;
+            };
+
+            tokio::select! {
+                result = request_loop => result,
+                () = async {
+                    while !interrupt.is_interrupted() {
+                        tokio::time::sleep(std::time::Duration::from_millis(50)).await;
+                    }
+                } => {
+                    // Dropping the request future aborts the in-flight HTTP
+                    // stream. The conversation loop sees the interrupt flag and
+                    // reports this as an interruption rather than a failure.
+                    Err(RuntimeError::new("request interrupted by user"))
                }
            }
-
-            Err(RuntimeError::new("post-tool continuation nudge exhausted"))
        })
    }
 }
@@ -19664,6 +19902,22 @@ UU conflicted.rs",
            super::explicit_provider_kind_for_model("openai/gpt-5", &config.model),
            Some(api::ProviderConfigKind::OpenAi)
        );
+        assert_eq!(
+            super::explicit_provider_kind_for_model("custom-openai/local-model", &config.model),
+            Some(api::ProviderConfigKind::CustomOpenAi)
+        );
+        assert_eq!(
+            super::explicit_provider_kind_for_model("CUSTOM-OPENAI/local-model", &config.model),
+            Some(api::ProviderConfigKind::CustomOpenAi)
+        );
+        assert_eq!(
+            super::explicit_provider_kind_for_model(
+                "custom-openai/local-model",
+                "custom-openai/local-model"
+            ),
+            None,
+            "matching custom model must keep the persisted provider kind"
+        );
        assert_eq!(
            super::explicit_provider_kind_for_model("qwen-plus", &config.model),
            None,
@@ -19704,6 +19958,44 @@ UU conflicted.rs",
        }
    }

+    #[test]
+    fn persisted_custom_openai_configuration_survives_runtime_boundary() {
+        let config_home = temp_dir();
+        let workspace = temp_dir();
+        fs::create_dir_all(&config_home).expect("config home");
+        fs::create_dir_all(&workspace).expect("workspace");
+        fs::write(
+            config_home.join("settings.json"),
+            r#"{
+              "provider": {
+                "kind": "custom-openai",
+                "apiKey": "custom-test-key",
+                "baseUrl": "https://custom.example/v1",
+                "model": "local-model"
+              },
+              "model": "local-model"
+            }"#,
+        )
+        .expect("write provider settings");
+
+        let loader = ConfigLoader::new(&workspace, &config_home);
+        let runtime_config = loader.load().expect("runtime config should load");
+        let provider_config = super::provider_config_from_runtime(runtime_config.provider())
+            .expect("custom provider configuration should adapt")
+            .expect("persisted provider configuration should be present");
+
+        assert_eq!(provider_config.kind, api::ProviderConfigKind::CustomOpenAi);
+        assert_eq!(provider_config.model, "local-model");
+        assert_eq!(provider_config.api_key.as_deref(), Some("custom-test-key"));
+        assert_eq!(
+            provider_config.base_url.as_deref(),
+            Some("https://custom.example/v1")
+        );
+
+        let _ = fs::remove_dir_all(config_home);
+        let _ = fs::remove_dir_all(workspace);
+    }
+
    #[test]
    fn persisted_provider_configuration_controls_runtime_provider_dispatch() {
        let config_home = temp_dir();
@@ -249,16 +249,6 @@ impl TerminalRenderer {

    #[must_use]
    pub fn render_markdown(&self, markdown: &str) -> String {
-        self.render_markdown_raw(markdown).trim_end().to_string()
-    }
-
-    /// Render markdown to ANSI without trimming trailing whitespace.
-    ///
-    /// Block-level events (paragraphs, headings, lists, code blocks) emit their
-    /// trailing newline separators here. `render_markdown` trims them for
-    /// one-shot output, while streaming keeps them so that successive chunks
-    /// stay on their own lines instead of running together.
-    fn render_markdown_raw(&self, markdown: &str) -> String {
        let normalized = normalize_nested_fences(markdown);
        let mut output = String::new();
        let mut state = RenderState::default();
@@ -277,7 +267,30 @@ impl TerminalRenderer {
            );
        }

-        output
+        output.trim_end().to_string()
+    }
+
+    /// Ensures the output ends with at least `required` newlines.
+    /// This is idempotent: calling it multiple times with the same output
+    /// will not add extra newlines beyond what is needed.
+    /// The function is crucial for streaming rendering where chunks may
+    /// split at block boundaries, causing the parser to lose newlines
+    /// that normally separate blocks.
+    fn ensure_newlines(output: &mut String, required: usize) {
+        if output.is_empty() {
+            // Don't start with blank lines
+            return;
+        }
+
+        // Count trailing newlines
+        let trailing_newlines = output.chars().rev().take_while(|&c| c == '\n').count();
+
+        // Add newlines if we don't have enough
+        if trailing_newlines < required {
+            for _ in 0..(required - trailing_newlines) {
+                output.push('\n');
+            }
+        }
    }

    #[must_use]
@@ -285,18 +298,6 @@ impl TerminalRenderer {
        self.render_markdown(markdown)
    }

-    /// Stream-friendly variant of `markdown_to_ansi` that preserves trailing
-    /// block separators (such as a paragraph's closing newlines).
-    ///
-    /// `MarkdownStreamState::push` writes each rendered chunk directly to the
-    /// terminal with no separator of its own, so the trailing newlines must
-    /// survive here to keep a paragraph from sticking to the block that follows
-    /// it. The final `flush` still uses `markdown_to_ansi` to trim the tail.
-    #[must_use]
-    pub fn markdown_to_ansi_stream(&self, markdown: &str) -> String {
-        self.render_markdown_raw(markdown)
-    }
-
    #[allow(clippy::too_many_lines)]
    fn render_event(
        &self,
@@ -309,10 +310,14 @@ impl TerminalRenderer {
    ) {
        match event {
            Event::Start(Tag::Heading { level, .. }) => {
+                Self::ensure_newlines(output, 1);
                Self::start_heading(state, level as u8, output);
            }
            Event::End(TagEnd::Paragraph) => output.push_str("\n\n"),
-            Event::Start(Tag::BlockQuote(..)) => self.start_quote(state, output),
+            Event::Start(Tag::BlockQuote(..)) => {
+                Self::ensure_newlines(output, 1);
+                self.start_quote(state, output);
+            }
            Event::End(TagEnd::BlockQuote(..)) => {
                state.quote = state.quote.saturating_sub(1);
                output.push('\n');
@@ -325,6 +330,7 @@ impl TerminalRenderer {
                state.append_raw(output, "\n");
            }
            Event::Start(Tag::List(first_item)) => {
+                Self::ensure_newlines(output, 1);
                let kind = match first_item {
                    Some(index) => ListKind::Ordered { next_index: index },
                    None => ListKind::Unordered,
@@ -337,6 +343,7 @@ impl TerminalRenderer {
            }
            Event::Start(Tag::Item) => Self::start_item(state, output),
            Event::Start(Tag::CodeBlock(kind)) => {
+                Self::ensure_newlines(output, 2);
                *in_code_block = true;
                *code_language = match kind {
                    CodeBlockKind::Indented => String::from("text"),
@@ -360,7 +367,10 @@ impl TerminalRenderer {
                    format!("{}", format!("`{code}`").with(self.color_theme.inline_code));
                state.append_raw(output, &rendered);
            }
-            Event::Rule => output.push_str("---\n"),
+            Event::Rule => {
+                Self::ensure_newlines(output, 1);
+                output.push_str("---\n");
+            }
            Event::Text(text) => {
                self.push_text(text.as_ref(), state, output, code_buffer, *in_code_block);
            }
@@ -405,7 +415,10 @@ impl TerminalRenderer {
                );
                state.append_raw(output, &rendered);
            }
-            Event::Start(Tag::Table(..)) => state.table = Some(TableState::default()),
+            Event::Start(Tag::Table(..)) => {
+                Self::ensure_newlines(output, 1);
+                state.table = Some(TableState::default());
+            }
            Event::End(TagEnd::Table) => {
                if let Some(table) = state.table.take() {
                    output.push_str(&self.render_table(&table));
@@ -619,9 +632,21 @@ impl TerminalRenderer {
    }
 }

-#[derive(Debug, Default, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct MarkdownStreamState {
    pending: String,
+    /// Track whether the last emitted output ended with a newline.
+    /// Used to ensure proper spacing when resuming from a buffer.
+    last_output_ends_with_newline: bool,
+}
+
+impl Default for MarkdownStreamState {
+    fn default() -> Self {
+        Self {
+            pending: String::new(),
+            last_output_ends_with_newline: false,
+        }
+    }
 }

 impl MarkdownStreamState {
@@ -631,7 +656,40 @@ impl MarkdownStreamState {
        let split = find_stream_safe_boundary(&self.pending)?;
        let ready = self.pending[..split].to_string();
        self.pending.drain(..split);
-        Some(renderer.markdown_to_ansi_stream(&ready))
+
+        let mut rendered = renderer.markdown_to_ansi(&ready);
+        let stripped = strip_ansi(&rendered);
+
+        // If the previous output didn't end with a newline and this chunk starts
+        // with a block-level element, ensure proper spacing before it.
+        if !self.last_output_ends_with_newline && !rendered.is_empty() {
+            if stripped.starts_with("\u{256d}\u{2500}")
+                || stripped.starts_with("```")
+                || stripped.starts_with("|")
+                || stripped.starts_with("• ")
+                || stripped.starts_with("1. ")
+                || stripped.starts_with("-")
+            {
+                rendered = format!("\n\n{}", rendered);
+            }
+        }
+
+        // When markdown ends with a code block closing marker or other block-level element,
+        // render_markdown() trims the trailing newlines that finish_code_block() added.
+        // For streaming, we need to restore these newlines so proper spacing is preserved
+        // when chunks are combined. This is critical for idempotence across re-renders.
+        if stripped.ends_with("\u{2570}\u{2500}")
+            || stripped.ends_with("---")
+            || stripped.ends_with("|")
+        {
+            // Block element that should have trailing spacing
+            if !rendered.ends_with('\n') {
+                rendered.push_str("\n\n");
+            }
+        }
+
+        self.last_output_ends_with_newline = rendered.ends_with('\n');
+        Some(rendered)
    }

    #[must_use]
@@ -641,7 +699,26 @@ impl MarkdownStreamState {
            None
        } else {
            let pending = std::mem::take(&mut self.pending);
-            Some(renderer.markdown_to_ansi(&pending))
+            let mut rendered = renderer.markdown_to_ansi(&pending);
+
+            // If the previous output didn't end with a newline and this output
+            // starts with a block-level element, ensure proper spacing.
+            if !self.last_output_ends_with_newline && !rendered.is_empty() {
+                // Check if output starts with a block element by looking for common markers
+                let stripped = strip_ansi(&rendered);
+                if stripped.starts_with("\u{256d}\u{2500}")
+                    || stripped.starts_with("```")
+                    || stripped.starts_with("|")
+                    || stripped.starts_with("• ")
+                    || stripped.starts_with("1. ")
+                    || stripped.starts_with("-")
+                {
+                    rendered = format!("\n\n{}", rendered);
+                }
+            }
+
+            self.last_output_ends_with_newline = rendered.ends_with('\n');
+            Some(rendered)
        }
    }
 }
@@ -835,6 +912,11 @@ fn normalize_nested_fences(markdown: &str) -> String {
    out
 }

+/// Find a safe boundary for streaming markdown rendering.
+/// Safe boundaries are:
+/// - After a closing fence line (when fence is closed)
+/// - After an empty line
+/// This function returns the position of the last safe boundary found.
 fn find_stream_safe_boundary(markdown: &str) -> Option<usize> {
    let mut open_fence: Option<FenceMarker> = None;
    let mut last_boundary = None;
@@ -1074,34 +1156,6 @@ mod tests {
        assert!(plain_text.contains("fn nested()"));
    }

-    #[test]
-    fn stream_rendering_preserves_block_separators() {
-        let renderer = TerminalRenderer::new();
-
-        // The stream variant keeps the paragraph-ending newlines that the
-        // one-shot variant trims, so consecutive streamed chunks do not run
-        // into each other when written back-to-back to the terminal.
-        let streamed = renderer.markdown_to_ansi_stream("Intro paragraph.\n\n");
-        assert!(streamed.ends_with('\n'));
-        assert!(!renderer
-            .markdown_to_ansi("Intro paragraph.\n\n")
-            .ends_with('\n'));
-
-        let mut state = MarkdownStreamState::default();
-        let first = state
-            .push(&renderer, "Intro paragraph.\n\n")
-            .expect("blank line closes the paragraph block");
-        let second = state
-            .push(&renderer, "1. first item\n\n")
-            .expect("blank line closes the list block");
-
-        let combined = strip_ansi(&format!("{first}{second}"));
-        assert!(combined.contains("Intro paragraph."));
-        assert!(combined.contains("1. first item"));
-        // The two blocks stay on separate lines instead of sticking together.
-        assert!(!combined.contains("Intro paragraph.1."));
-    }
-
    #[test]
    fn spinner_advances_frames() {
        let terminal_renderer = TerminalRenderer::new();
@@ -1117,4 +1171,189 @@ mod tests {
        let output = String::from_utf8_lossy(&out);
        assert!(output.contains("Working"));
    }
+
+    #[test]
+    fn streaming_text_before_code_block_preserves_newline_boundary() {
+        let renderer = TerminalRenderer::new();
+        let mut state = MarkdownStreamState::default();
+
+        // Simulate streaming: paragraph text arrives in one chunk
+        assert_eq!(
+            state.push(&renderer, "This is some text."),
+            None,
+            "incomplete paragraph should not flush"
+        );
+
+        // Then code block arrives in the next chunk
+        let rendered = state
+            .push(&renderer, "\n\n```rust\nfn main() {}\n```\n")
+            .expect("fenced block should trigger flush");
+        let plain_text = strip_ansi(&rendered);
+
+        // Verify the paragraph text and code block are present
+        assert!(plain_text.contains("This is some text."));
+        assert!(plain_text.contains("fn main()"));
+
+        // The critical check: there should be a blank line between the paragraph and code block
+        // The paragraph ends, then there should be newlines before the code block marker
+        let lines: Vec<&str> = plain_text.lines().collect();
+        let text_line_idx = lines
+            .iter()
+            .position(|line| line.contains("This is some text."))
+            .expect("find text line");
+        // Skip past the text line and find the code block
+        let code_marker_idx = lines[text_line_idx + 1..]
+            .iter()
+            .position(|line| line.contains("╭─ rust"))
+            .map(|i| i + text_line_idx + 1);
+
+        // There should be at least one empty line between the text and the code block marker
+        if let Some(code_idx) = code_marker_idx {
+            assert!(
+                code_idx > text_line_idx + 1,
+                "there should be spacing between paragraph and code block"
+            );
+        }
+    }
+
+    #[test]
+    fn rendering_paragraph_immediately_before_code_block_has_blank_line() {
+        let renderer = TerminalRenderer::new();
+        let markdown = "This is a paragraph.\n\n```rust\nfn main() {}\n```";
+        let output = renderer.markdown_to_ansi(markdown);
+        let plain_text = strip_ansi(&output);
+        let lines: Vec<&str> = plain_text.lines().collect();
+
+        // Find the paragraph and code block
+        let text_idx = lines
+            .iter()
+            .position(|l| l.contains("This is a paragraph."))
+            .expect("find paragraph");
+        let code_idx = lines[text_idx + 1..]
+            .iter()
+            .position(|l| l.contains("╭─ rust"))
+            .map(|i| i + text_idx + 1)
+            .expect("find code block");
+
+        // There should be at least one blank line between them
+        assert!(
+            code_idx > text_idx + 1,
+            "code block should not immediately follow paragraph"
+        );
+    }
+
+    #[test]
+    fn code_block_ending_with_trailing_text_preserves_spacing() {
+        let renderer = TerminalRenderer::new();
+        let markdown = "```rust\nfn main() {}\n```\n\nText after.";
+        let output = renderer.markdown_to_ansi(markdown);
+        let plain_text = strip_ansi(&output);
+
+        // The code block should end with "╰─" followed by blank lines, then text
+        assert!(
+            plain_text.contains("\u{256d}\u{2500}"),
+            "should contain code block close marker"
+        );
+        assert!(
+            plain_text.contains("\n\nText"),
+            "should have blank line before text"
+        );
+    }
+
+    #[test]
+    fn streaming_code_block_preserves_trailing_newlines() {
+        let renderer = TerminalRenderer::new();
+        let mut state = MarkdownStreamState::default();
+        let markdown = "Text before.\n\n```rust\nfn test() {}\n```\n\nText after.";
+
+        // Debug: let's check what the code block part alone renders to
+        let code_part = "```rust\nfn test() {}\n```\n\nText after.";
+        let code_rendered = strip_ansi(&renderer.markdown_to_ansi(code_part));
+
+        // Simulate the streaming at split position 1
+        let r1 = state.push(&renderer, "T").map(|s| strip_ansi(&s));
+        let r2 = state
+            .push(
+                &renderer,
+                "ext before.\n\n```rust\nfn test() {}\n```\n\nText after.",
+            )
+            .map(|s| strip_ansi(&s));
+
+        // After r2, the pending should contain the code block part
+        let pending_before_r3 = state.pending.clone();
+
+        let r3 = state.flush(&renderer).map(|s| strip_ansi(&s));
+
+        // Combine the results
+        let mut full_streamed = String::new();
+        if let Some(s) = &r1 {
+            full_streamed.push_str(s);
+        }
+        if let Some(s) = &r2 {
+            full_streamed.push_str(s);
+        }
+        if let Some(s) = &r3 {
+            full_streamed.push_str(s);
+        }
+
+        let full_rendered = strip_ansi(&renderer.markdown_to_ansi(markdown));
+
+        assert_eq!(full_streamed, full_rendered,
+            "Streaming mismatch.\n\nCode part alone renders to: {:?}\nPending before r3: {:?}\n\nBreakdown:\n  r1: {:?}\n  r2: {:?}\n  r3: {:?}\n\nExpected:\n{:?}\n\nGot:\n{:?}",
+            code_rendered, pending_before_r3, r1, r2, r3, full_rendered, full_streamed);
+    }
+
+    #[test]
+    fn streaming_with_split_at_every_byte_position_produces_consistent_output() {
+        let renderer = TerminalRenderer::new();
+        let markdown = "Text before.\n\n```rust\nfn test() {}\n```\n\nText after.";
+
+        // First, render the full document
+        let full_output = renderer.markdown_to_ansi(markdown);
+        let full_plain = strip_ansi(&full_output);
+
+        // Now simulate streaming by splitting at different positions
+        for split_pos in 1..markdown.len() {
+            let mut state = MarkdownStreamState::default();
+            let part1 = &markdown[..split_pos];
+            let part2 = &markdown[split_pos..];
+
+            // Try to push both parts
+            let r1 = state.push(&renderer, part1);
+            let r2 = state.push(&renderer, part2);
+            let final_r = state.flush(&renderer);
+
+            // Reconstruct the streamed output
+            let mut streamed_output = String::new();
+            if let Some(out) = r1 {
+                streamed_output.push_str(&out);
+            }
+            if let Some(out) = r2 {
+                streamed_output.push_str(&out);
+            }
+            if let Some(out) = final_r {
+                streamed_output.push_str(&out);
+            }
+
+            let streamed_plain = strip_ansi(&streamed_output);
+
+            if streamed_plain != full_plain {
+                eprintln!("\n=== MISMATCH at split position {} ===", split_pos);
+                eprintln!("Part 1: {:?}", part1);
+                eprintln!("Part 2: {:?}", part2);
+                eprintln!("\nExpected (full):");
+                eprintln!("{:?}", full_plain);
+                eprintln!("\nGot (streamed):");
+                eprintln!("{:?}", streamed_plain);
+                eprintln!("\nStreamed rendered output:");
+                eprintln!("{:?}", streamed_output);
+            }
+
+            assert_eq!(
+                streamed_plain, full_plain,
+                "streaming with split at position {} produces different output",
+                split_pos
+            );
+        }
+    }
 }
@@ -9,7 +9,7 @@ const PROVIDERS: &[(&str, &str, &str)] = &[
    ("2", "xAI / Grok", "xai"),
    ("3", "OpenAI", "openai"),
    ("4", "DashScope (Qwen/Kimi)", "dashscope"),
-    ("5", "Custom (OpenAI-compat)", "openai"),
+    ("5", "Custom (OpenAI-compat)", "custom-openai"),
 ];

 const PROVIDER_MODELS: &[(&str, &[&str])] = &[
@@ -27,6 +27,8 @@ const DEFAULT_BASE_URLS: &[(&str, &str)] = &[
        "dashscope",
        "https://dashscope.aliyuncs.com/compatible-mode/v1",
    ),
+    // Custom OpenAI has no default; user must supply.
+    ("custom-openai", ""),
 ];

 const API_KEY_ENV_VARS: &[(&str, &str)] = &[
@@ -34,6 +36,7 @@ const API_KEY_ENV_VARS: &[(&str, &str)] = &[
    ("xai", "XAI_API_KEY"),
    ("openai", "OPENAI_API_KEY"),
    ("dashscope", "DASHSCOPE_API_KEY"),
+    ("custom-openai", "CLAWCUSTOMOPENAI_API_KEY"),
 ];

 pub fn run_setup_wizard() -> Result<(), Box<dyn std::error::Error>> {
@@ -177,6 +180,7 @@ fn prompt_base_url(
        "xai" => "XAI_BASE_URL",
        "openai" => "OPENAI_BASE_URL",
        "dashscope" => "DASHSCOPE_BASE_URL",
+        "custom-openai" => "CLAWCUSTOMOPENAI_BASE_URL",
        _ => "BASE_URL",
    };
    let env_set = std::env::var(env_var).ok().is_some_and(|v| !v.is_empty());
@@ -214,7 +218,11 @@ fn prompt_model(
    if !aliases.is_empty() {
        println!("    Common: {}", aliases.join(", "));
    }
-    println!("    Or enter any model name (e.g. openai/gpt-4.1-mini for custom routing)");
+    if kind == "custom-openai" {
+        println!("    Or enter any model name (e.g. custom/gpt-4.1 for custom routing)");
+    } else {
+        println!("    Or enter any model name (e.g. openai/gpt-4.1-mini for custom routing)");
+    }

    let input = read_line(&format!("  Model [{current_model}]: "))?;
    if input.trim().is_empty() {
@@ -1,6 +1,6 @@
 [package]
 name = "sdk"
-version = "0.1.0"
+version = "0.1.4"
 edition = "2021"
 publish = false

@@ -20,7 +20,7 @@ use runtime::{
    lsp_client::LspRegistry,
    mcp_tool_bridge::McpToolRegistry,
    permission_enforcer::{EnforcementResult, PermissionEnforcer},
-    read_file_in_workspace,
+    read_file_in_workspace_with_selector,
    summary_compression::compress_summary_text,
    task_registry::TaskRegistry,
    team_cron_registry::{CronRegistry, TeamRegistry},
@@ -2569,8 +2569,14 @@ fn branch_divergence_output(
 fn run_read_file(input: ReadFileInput) -> Result<String, String> {
    let workspace = std::env::current_dir().map_err(|error| error.to_string())?;
    to_pretty_json(
-        read_file_in_workspace(&input.path, input.offset, input.limit, &workspace)
-            .map_err(io_to_string)?,
+        read_file_in_workspace_with_selector(
+            &input.path,
+            input.offset,
+            input.limit,
+            input.selector.as_deref(),
+            &workspace,
+        )
+        .map_err(io_to_string)?,
    )
 }

@@ -2885,6 +2891,7 @@ struct ReadFileInput {
    path: String,
    offset: Option<usize>,
    limit: Option<usize>,
+    selector: Option<String>,
 }

 #[derive(Debug, Deserialize)]
@@ -10690,6 +10697,43 @@ printf 'pwsh:%s' "$1"
        let _ = fs::remove_dir_all(root);
    }

+    #[test]
+    fn given_read_only_enforcer_when_read_file_with_selector_then_succeeds() {
+        let _guard = env_lock()
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
+        let root = temp_path("perm-read-selector");
+        fs::create_dir_all(&root).expect("create root");
+        let file = root.join("multi-line.txt");
+        fs::write(&file, "line1\nline2\nline3\nline4\nline5\n").expect("write test file");
+        let original_dir = std::env::current_dir().expect("cwd");
+        std::env::set_current_dir(&root).expect("set cwd");
+
+        let registry = read_only_registry();
+        let result = registry.execute(
+            "read_file",
+            &json!({
+                "path": file.display().to_string(),
+                "selector": "2-4"
+            }),
+        );
+        assert!(
+            result.is_ok(),
+            "read_file with selector should succeed: {result:?}"
+        );
+
+        // Verify the output contains the expected lines
+        let output: serde_json::Value =
+            serde_json::from_str(&result.unwrap()).expect("json output");
+        let content = output["file"]["content"].as_str().expect("content field");
+        assert!(content.contains("line2"));
+        assert!(content.contains("line3"));
+        assert!(content.contains("line4"));
+
+        std::env::set_current_dir(&original_dir).expect("restore cwd");
+        let _ = fs::remove_dir_all(root);
+    }
+
    #[test]
    fn given_read_only_enforcer_when_glob_search_then_not_permission_denied() {
        let registry = read_only_registry();