diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8bd411c..322ba0a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,30 @@ 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).
 
+## [Unreleased]
+
+## [1.2.0] - 2026-04-25
+
+### Added
+
+- **write**: Japanese (`ja`), Korean (`ko`), and Simplified Chinese (`zh`, `zh-Hans`) are now accepted target languages for `deepl write`.
+- **write**: `--tone` and `--style` now apply to Spanish (`es`), Italian (`it`), French (`fr`), and Portuguese (`pt`, `pt-BR`, `pt-PT`) in addition to the previously supported locales. The full value lists on `--tone` and `--style` are unchanged — the same 9 styles and 9 tones are accepted, and the mutual-exclusion rule between `--style` and `--tone` is unchanged. See `docs/API.md` for supported target-language / style / tone combinations.
+- **write**: 4xx responses from the Write API that arrive while `--style` or `--tone` is set now carry an explicit recovery hint pointing at `docs/API.md` for supported target-language / style / tone combinations.
+- **style-rules**: Full CRUD — `deepl style-rules create|show|update|delete` alongside the existing `list`. `create` requires `--name` and `--language`. `update` accepts `--name` for a rename and `--rules` for replacing configured rules (PUT `/configured_rules`); at least one is required. `--rules` takes a JSON object of category → settings, e.g. `'{"punctuation":{"quotation_mark":"use_guillemets"}}'` — matching the DeepL API's two-level rule shape. `delete` supports `-y`/`--yes`, `--dry-run`, and a TTY confirmation prompt. All new subcommands support `--format text|json`. Text-format output sanitizes control characters from rule names, configured-rule keys/values, and instruction text.
+- **style-rules**: Custom instructions management — `deepl style-rules instructions <style-rule-id>` (list, synthesized from the detailed `show` response), plus `add-instruction <style-id> <label> <prompt>`, `update-instruction <style-id> <label> <prompt>`, and `remove-instruction <style-id> <label>` subcommands. `remove-instruction` ships `-y`/`--yes`, `--dry-run`, and a TTY confirmation prompt (custom instructions are user-authored text and deserve confirmation before deletion).
+- **style-rules**: `deepl style-rules list` and `deepl style-rules instructions <style-rule-id>` accept `--format table` for aligned column output via `cli-table3`, matching the existing `translate`, `languages`, `usage`, and `cache` commands. In non-TTY output (pipe, redirect, CI), table falls back to plain text with a `WARN` line on stderr — same pattern used by `deepl translate --format table`.
+- **examples**: `examples/35-style-rules-crud.sh` — end-to-end style-rules workflow (create → show → update rules → add custom instruction → update instruction → remove instruction → delete rule).
+- **examples**: `examples/36-write-extended-languages.sh` — `deepl write` with Japanese, Korean, and Simplified Chinese targets and tone / style applied to Spanish, Italian, French, and Portuguese variants.
+
+### Fixed
+
+- **languages / cache stats / usage**: `--format table` now actually renders a `cli-table3` table on these commands. Previously the flag was advertised in `--help` but the action handler only branched on `'json'`, so `--format table` silently produced text output. Same non-TTY fallback as the other table commands.
+- **sync**: `deepl sync export --output <path>` (and other sync surfaces that call `assertPathWithinRoot`) no longer reject valid output paths under a project root that contains a symlink in its ancestor chain. The containment check now resolves both sides through `fs.realpath` before comparing, so a project under macOS `/tmp` (a symlink to `/private/tmp`) — or any other symlinked directory — works regardless of which form the user types or the engine captures. Symlink-based escape attempts (a symlink inside the project pointing outside) are now also rejected as a defense-in-depth bonus.
+
+### Security
+
+- **api**: Server-returned error messages are now passed through `sanitizeForTerminal` before being interpolated into the user-facing `API error: …` and `Server error (5xx): …` strings emitted from `src/api/http-client.ts`. Defense-in-depth against a buggy or malicious server scribbling ANSI escape codes or other terminal control characters on the user's terminal via the error path. Mirrors the existing TMS-client hardening; no change to error-message wording when the server payload is well-formed.
+
 ## [1.1.0] - 2026-04-23
 
 ### Added
diff --git a/VERSION b/VERSION
index 9084fa2..26aaba0 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-1.1.0
+1.2.0
diff --git a/docs/API.md b/docs/API.md
index 8d8860e..f7a6aea 100644
--- a/docs/API.md
+++ b/docs/API.md
@@ -1,7 +1,7 @@
 # DeepL CLI - API Reference
 
-**Version**: 1.1.0
-**Last Updated**: April 23, 2026
+**Version**: 1.2.0
+**Last Updated**: April 25, 2026
 
 Complete reference for all DeepL CLI commands, options, and configuration.
 
@@ -664,7 +664,7 @@ deepl write [OPTIONS] TEXT
 
 #### Description
 
-Enhance text quality with AI-powered grammar checking, style improvement, and tone adjustment. Supports 8 languages.
+Enhance text quality with AI-powered grammar checking, style improvement, and tone adjustment. Supports 14 target languages.
 
 **File Detection:** The command automatically detects if the text argument is a file path. If a file exists at that path, it operates on the file; otherwise, it treats the argument as text to improve.
 
@@ -672,7 +672,7 @@ Enhance text quality with AI-powered grammar checking, style improvement, and to
 
 **Language:**
 
-- `--lang, -l LANG` - Target language: `de`, `en`, `en-GB`, `en-US`, `es`, `fr`, `it`, `pt`, `pt-BR`, `pt-PT`. Optional — omit to auto-detect the language and rephrase in the original language.
+- `--lang, -l LANG` - Target language: `de`, `en`, `en-GB`, `en-US`, `es`, `fr`, `it`, `ja`, `ko`, `pt`, `pt-BR`, `pt-PT`, `zh`, `zh-Hans`. Optional — omit to auto-detect the language and rephrase in the original language.
 - `--to LANG` - Long-only alias of `--lang`. Accepts the same language values. Provided for muscle-memory consistency with `deepl translate --to`; the short form `-t` is intentionally **not** bound here (it would collide with `deepl translate -t, --to`). Specifying both `--to` and `--lang` with different values exits with a `ValidationError`.
 
 **Style Options (mutually exclusive with tone):**
@@ -695,6 +695,16 @@ Enhance text quality with AI-powered grammar checking, style improvement, and to
   - `diplomatic` - More careful and tactful
   - `prefer_enthusiastic`, `prefer_friendly`, etc. - Soft preferences
 
+**Supported target-language / style-and-tone combinations:**
+
+| Target language | `--style` | `--tone` |
+|-----------------|:---------:|:--------:|
+| `en`, `en-GB`, `en-US`, `de` | ✓ | ✓ |
+| `es`, `fr`, `it`, `pt`, `pt-BR`, `pt-PT` | ✓ | ✓ |
+| `ja`, `ko`, `zh`, `zh-Hans` | — | — |
+
+When `--style` or `--tone` is set for a target language that does not support it, the server returns a 4xx; the CLI converts that response into a `ValidationError` (exit code 6) that names the unsupported combination and points back to this table.
+
 **Output Options:**
 
 - `--alternatives, -a` - Show all improvement alternatives
@@ -2000,7 +2010,7 @@ Show cache statistics (status, entries count, size, percentage used).
 
 **Options:**
 
-- `--format <format>` - Output format: `text`, `json`, `table` (default: `text`)
+- `--format <format>` - Output format: `text`, `json`, `table` (default: `text`). In non-TTY output, `table` falls back to `text` with a `WARN` line on stderr.
 
 ##### `clear`
 
@@ -2139,7 +2149,7 @@ Display your DeepL API character usage and remaining quota. Helps you monitor co
 
 #### Options
 
-- `--format FORMAT` - Output format: `text`, `json`, `table` (default: `text`)
+- `--format FORMAT` - Output format: `text`, `json`, `table` (default: `text`). In non-TTY output, `table` falls back to `text` with a `WARN` line on stderr.
 
 #### Examples
 
@@ -2215,7 +2225,7 @@ You can filter to show only source languages, only target languages, or both (de
 
 - `--source, -s` - Show only source languages
 - `--target` - Show only target languages
-- `--format FORMAT` - Output format: `text`, `json`, `table` (default: `text`)
+- `--format FORMAT` - Output format: `text`, `json`, `table` (default: `text`). In non-TTY output, `table` falls back to `text` with a `WARN` line on stderr.
 
 #### Examples
 
@@ -2462,7 +2472,7 @@ deepl auth clear
 
 ### style-rules
 
-Manage DeepL style rules (Pro API only). Style rules are created via the DeepL web UI and applied to translations using their ID.
+Manage DeepL style rules (Pro API only). Style rules carry a list of configured rule ids and optional custom instructions, and apply to translations via their style id.
 
 #### Synopsis
 
@@ -2481,30 +2491,208 @@ List all available style rules.
 - `--detailed` - Show detailed information including configured rules and custom instructions
 - `--page NUMBER` - Page number for pagination
 - `--page-size NUMBER` - Number of results per page (1-25)
-- `--format FORMAT` - Output format: `text`, `json` (default: `text`)
+- `--format FORMAT` - Output format: `text`, `json`, `table` (default: `text`). In non-TTY output, `table` falls back to `text` with a `WARN` line on stderr.
 
 **Examples:**
 
 ```bash
-# List all style rules
 deepl style-rules list
-
-# List with details
 deepl style-rules list --detailed
-
-# JSON output
 deepl style-rules list --format json
-
-# Pagination
+deepl style-rules list --format table
 deepl style-rules list --page 1 --page-size 10
 ```
 
+##### `create`
+
+Create a new style rule list.
+
+**Options:**
+
+- `--name NAME` - Style rule name (required)
+- `--language LANG` - Target language (required)
+- `--rules JSON` - Configured rules as a JSON object of category → settings (optional). The DeepL API models configured rules as a two-level dictionary; arrays are not accepted. See "Configured rules shape" below.
+- `--format FORMAT` - Output format: `text`, `json` (default: `text`)
+
+**Examples:**
+
+```bash
+deepl style-rules create --name "Corporate" --language en
+deepl style-rules create --name "Québécois" --language fr \
+  --rules '{"punctuation":{"quotation_mark":"use_guillemets"}}'
+```
+
+**Configured rules shape:**
+
+The DeepL API expects `configured_rules` as a nested object — a category name maps to a settings object, and each setting maps to a string value. Empty rules are `{}`. Example for fr-CA:
+
+```json
+{
+  "punctuation": {
+    "quotation_mark": "use_guillemets",
+    "spacing_and_punctuation": "do_not_use_space"
+  },
+  "spelling_and_grammar": {
+    "accents_and_cedillas": "use_even_on_capital_letters"
+  }
+}
+```
+
+The available categories, settings, and accepted values are defined by the DeepL API; consult DeepL's API documentation for the current rule schema.
+
+##### `show`
+
+Show a single style rule.
+
+**Arguments:**
+
+- `<id>` - Style rule id (required)
+
+**Options:**
+
+- `--detailed` - Include configured rules and custom instructions
+- `--format FORMAT` - Output format: `text`, `json` (default: `text`)
+
+**Examples:**
+
+```bash
+deepl style-rules show sr-abc123
+deepl style-rules show sr-abc123 --detailed --format json
+```
+
+##### `update`
+
+Update a style rule — rename and/or replace configured rules. At least one of `--name` / `--rules` is required. When both are provided, the rename (PATCH) runs first, then the rules replacement (PUT `/configured_rules`).
+
+**Arguments:**
+
+- `<id>` - Style rule id (required)
+
+**Options:**
+
+- `--name NAME` - New name
+- `--rules JSON` - Replace configured rules with a JSON object of category → settings (see "Configured rules shape" under `create`)
+- `--format FORMAT` - Output format: `text`, `json` (default: `text`)
+
+**Examples:**
+
+```bash
+deepl style-rules update sr-abc123 --name "Renamed"
+deepl style-rules update sr-abc123 --rules '{"punctuation":{"quotation_mark":"use_guillemets"}}'
+deepl style-rules update sr-abc123 --name "New" --rules '{"spelling_and_grammar":{"accents_and_cedillas":"use_even_on_capital_letters"}}'
+```
+
+##### `delete`
+
+Delete a style rule. Prompts for confirmation on a TTY; use `--yes` to skip or `--dry-run` to preview.
+
+**Arguments:**
+
+- `<id>` - Style rule id (required)
+
+**Options:**
+
+- `-y`, `--yes` - Skip confirmation prompt
+- `--dry-run` - Show what would be deleted without performing the operation
+
+**Examples:**
+
+```bash
+deepl style-rules delete sr-abc123
+deepl style-rules delete sr-abc123 --yes
+deepl style-rules delete sr-abc123 --dry-run
+```
+
+##### `instructions`
+
+List custom instructions attached to a style rule. Synthesized from the detailed `show` response.
+
+**Arguments:**
+
+- `<style-id>` - Style rule id (required)
+
+**Options:**
+
+- `--format FORMAT` - Output format: `text`, `json`, `table` (default: `text`). In non-TTY output, `table` falls back to `text` with a `WARN` line on stderr.
+
+**Examples:**
+
+```bash
+deepl style-rules instructions sr-abc123
+deepl style-rules instructions sr-abc123 --format json
+deepl style-rules instructions sr-abc123 --format table
+```
+
+##### `add-instruction`
+
+Add a custom instruction to a style rule.
+
+**Arguments:**
+
+- `<style-id>` - Style rule id (required)
+- `<label>` - Instruction label, unique within the rule (required)
+- `<prompt>` - Instruction prompt text (required)
+
+**Options:**
+
+- `--source-language LANG` - Source language code (optional)
+- `--format FORMAT` - Output format: `text`, `json` (default: `text`)
+
+**Examples:**
+
+```bash
+deepl style-rules add-instruction sr-abc123 tone "Be formal"
+deepl style-rules add-instruction sr-abc123 register "Use first person" --source-language en
+```
+
+##### `update-instruction`
+
+Update the prompt and/or source language of an existing custom instruction. The label cannot be changed (it is the identifier); rename by removing and re-adding.
+
+**Arguments:**
+
+- `<style-id>` - Style rule id (required)
+- `<label>` - Instruction label (required)
+- `<prompt>` - New instruction prompt text (required)
+
+**Options:**
+
+- `--source-language LANG` - Source language code (optional)
+- `--format FORMAT` - Output format: `text`, `json` (default: `text`)
+
+**Examples:**
+
+```bash
+deepl style-rules update-instruction sr-abc123 tone "Be friendlier"
+```
+
+##### `remove-instruction`
+
+Remove a custom instruction from a style rule. Prompts for confirmation on a TTY.
+
+**Arguments:**
+
+- `<style-id>` - Style rule id (required)
+- `<label>` - Instruction label (required)
+
+**Options:**
+
+- `-y`, `--yes` - Skip confirmation prompt
+- `--dry-run` - Show what would be removed without performing the operation
+
+**Examples:**
+
+```bash
+deepl style-rules remove-instruction sr-abc123 tone --yes
+deepl style-rules remove-instruction sr-abc123 tone --dry-run
+```
+
 #### Notes
 
-- Style rules are created and managed via the DeepL web interface, not through the API
-- Style rules are Pro API only and datacenter-specific (EU and US rules don't cross)
-- Use the style ID from `style-rules list` with `deepl translate --style-id <uuid>`
-- Style rules force the `quality_optimized` model type
+- Style rules are Pro API only and datacenter-specific (EU and US rules don't cross).
+- Use the style id with `deepl translate --style-id <uuid>` to apply a rule at translation time.
+- Style rules force the `quality_optimized` model type.
+- Text-format output of stored user strings (rule names, instruction labels, instruction prompts) passes through a terminal-escape sanitizer to prevent injection of control characters from the API response. JSON-format output preserves raw strings (JSON-escaped at the encoding layer).
 
 ### admin
 
diff --git a/examples/15-glossaries.sh b/examples/15-glossaries.sh
index eccdb12..5eb921c 100755
--- a/examples/15-glossaries.sh
+++ b/examples/15-glossaries.sh
@@ -51,6 +51,27 @@ echo
 # BASIC GLOSSARY OPERATIONS
 # ═══════════════════════════════════════════════════════
 
+# Idempotent setup: previously-aborted runs may have left glossaries with
+# these demo names on the server (the script renames tech-terms-demo →
+# tech-terms-renamed → tech-final, so any of those three may be lingering),
+# and multiple aborted runs can leave duplicates of the same name. Delete
+# every matching glossary by UUID via the JSON listing so the run starts
+# from a clean slate.
+echo "0. Pre-run cleanup of any leftover demo glossaries"
+if command -v jq &>/dev/null; then
+  DEMO_NAMES='tech-terms-demo tech-terms-renamed tech-final business-terms-demo multi-demo'
+  for name in $DEMO_NAMES; do
+    deepl glossary list --format json 2>/dev/null \
+      | jq -r --arg n "$name" '.[] | select(.name == $n) | .glossary_id' 2>/dev/null \
+      | while read -r id; do
+        [[ -n "$id" ]] && deepl glossary delete "$id" --yes 2>/dev/null || true
+      done
+  done
+else
+  echo "   (jq not installed — skipping pre-run cleanup; install jq for full idempotency)"
+fi
+echo
+
 # Example 1: Create a glossary
 echo "1. Create tech glossary (EN → DE)"
 deepl glossary create tech-terms-demo en de "$SAMPLE_DIR/tech-glossary.tsv"
diff --git a/examples/32-sync-live-validation.sh b/examples/32-sync-live-validation.sh
index 73caa9b..c020f87 100755
--- a/examples/32-sync-live-validation.sh
+++ b/examples/32-sync-live-validation.sh
@@ -26,15 +26,18 @@ cleanup() {
 }
 trap cleanup EXIT
 
+# NOTE: under `set -e`, `((PASS++))` exits with status 1 when PASS is 0
+# (post-increment evaluates to the OLD value, which arithmetic context
+# treats as failure). Use plain assignment to always return 0.
 assert() {
   local desc="$1"
   shift
   if "$@" >/dev/null 2>&1; then
     echo "  ✓ $desc"
-    ((PASS++))
+    PASS=$((PASS + 1))
   else
     echo "  ✗ FAIL: $desc"
-    ((FAIL++))
+    FAIL=$((FAIL + 1))
   fi
 }
 
@@ -48,10 +51,10 @@ assert_exit_code() {
   "$@" >/dev/null 2>&1 || actual=$?
   if [ "$actual" -eq "$expected" ]; then
     echo "  ✓ $desc (exit $actual)"
-    ((PASS++))
+    PASS=$((PASS + 1))
   else
     echo "  ✗ FAIL: $desc (expected exit $expected, got $actual)"
-    ((FAIL++))
+    FAIL=$((FAIL + 1))
   fi
 }
 
@@ -206,8 +209,14 @@ deepl sync status 2>&1 | head -10
 assert_exit_code "status exits 0" 0 deepl sync status
 
 STATUS_JSON=$(deepl sync status --format json 2>&1)
-assert "status JSON is valid" echo "$STATUS_JSON" | python3 -c "import sys,json; json.load(sys.stdin)"
-assert "status shows source locale" echo "$STATUS_JSON" | python3 -c "import sys,json; d=json.load(sys.stdin); assert d['sourceLocale']=='en'"
+# Wrap pipelines inside helper functions so the assert helper runs them
+# atomically. Otherwise `assert "desc" echo $X | python3 ...` parses the
+# pipe at the assert call level — assert sees only `echo $X` (always 0)
+# and python receives assert's own "✓ desc\n" stdout instead of the JSON.
+_check_status_json_valid() { printf '%s\n' "$STATUS_JSON" | python3 -c "import sys,json; json.load(sys.stdin)"; }
+_check_status_source_en() { printf '%s\n' "$STATUS_JSON" | python3 -c "import sys,json; d=json.load(sys.stdin); assert d['sourceLocale']=='en'"; }
+assert "status JSON is valid" _check_status_json_valid
+assert "status shows source locale" _check_status_source_en
 
 assert_exit_code "validate exits 0" 0 deepl sync validate
 echo
@@ -218,15 +227,15 @@ echo "Phase 6: Force + Locale Filter"
 deepl sync --force --yes --locale de 2>&1 | head -10
 assert_exit_code "force+locale exits 0" 0 deepl sync --force --yes --locale de
 
-deepl sync --dry-run --force 2>&1 | head -10
-assert_exit_code "dry-run+force exits 0" 0 deepl sync --dry-run --force
+deepl sync --dry-run --force --yes 2>&1 | head -10
+assert_exit_code "dry-run+force exits 0" 0 deepl sync --dry-run --force --yes
 echo
 
 # ── Phase 7: PO Plurals ─────────────────────────────────────────────
 echo "Phase 7: PO Format with Plurals"
 
-mkdir -p locales/po
-cat > locales/po/messages.po << 'POEOF'
+mkdir -p locales/en/po
+cat > locales/en/po/messages.po << 'POEOF'
 # English translations
 msgid ""
 msgstr ""
@@ -258,11 +267,11 @@ buckets:
       - "locales/en.yaml"
   po:
     include:
-      - "locales/po/messages.po"
+      - "locales/en/po/messages.po"
 EOF
 
 deepl sync 2>&1 | head -10
-assert_file_exists "de PO target created" locales/po/de/messages.po || assert_file_exists "de PO (alt path)" "locales/de/po/messages.po" || true
+assert_file_exists "de PO target created" locales/de/po/messages.po
 echo
 
 # ── Phase 8: Android XML ────────────────────────────────────────────
@@ -300,9 +309,10 @@ buckets:
   yaml:
     include:
       - "locales/en.yaml"
-  xml:
+  android_xml:
     include:
       - "locales/values/strings.xml"
+    target_path_pattern: "locales/values-{locale}/strings.xml"
 EOF
 
 deepl sync 2>&1 | head -10
diff --git a/examples/35-style-rules-crud.sh b/examples/35-style-rules-crud.sh
new file mode 100755
index 0000000..fc4d6e0
--- /dev/null
+++ b/examples/35-style-rules-crud.sh
@@ -0,0 +1,93 @@
+#!/bin/bash
+# Example 35: Style Rules CRUD
+# End-to-end walkthrough of creating, updating, and deleting a style rule,
+# including custom instruction management. Pro API only.
+
+set -e
+
+echo "=== DeepL CLI Example 35: Style Rules CRUD ==="
+echo
+
+# Check if API key is configured
+if ! deepl auth show &>/dev/null; then
+  echo "❌ Error: API key not configured"
+  echo "Run: deepl auth set-key YOUR_API_KEY"
+  exit 1
+fi
+
+echo "✓ API key configured"
+echo
+echo "Note: Style rules require a Pro API key. On Free-tier keys,"
+echo "each command below will return a Pro-only error, which is expected."
+echo
+
+# Capture a style id on exit so we can clean up if anything fails partway
+STYLE_ID=""
+cleanup() {
+  if [[ -n "${STYLE_ID}" ]]; then
+    echo
+    echo "Cleanup: removing test style rule ${STYLE_ID}"
+    deepl style-rules delete "${STYLE_ID}" --yes 2>/dev/null || true
+  fi
+}
+trap cleanup EXIT
+
+# 1. Create a style rule (French so the punctuation rule below applies)
+echo "1. Creating a new style rule"
+CREATE_OUTPUT=$(deepl style-rules create --name "Example Corporate" --language fr --format json 2>&1)
+echo "${CREATE_OUTPUT}"
+if command -v jq &>/dev/null; then
+  STYLE_ID=$(echo "${CREATE_OUTPUT}" | jq -r '.styleId // empty' 2>/dev/null || true)
+else
+  echo "(jq not installed — install jq to capture the style id and run the full demo)"
+  exit 0
+fi
+if [[ -z "${STYLE_ID}" ]]; then
+  echo "(Skipping remainder — no style id captured; likely a Pro-only error)"
+  exit 0
+fi
+echo "Created style rule: ${STYLE_ID}"
+echo
+
+# 2. Show the rule (detailed)
+echo "2. Showing the rule (detailed)"
+deepl style-rules show "${STYLE_ID}" --detailed
+echo
+
+# 3. Replace configured rules (--rules takes a JSON object: category → settings)
+echo "3. Replacing configured rules"
+deepl style-rules update "${STYLE_ID}" --rules '{"punctuation":{"quotation_mark":"use_guillemets"}}'
+echo
+
+# 4. Add a custom instruction
+echo "4. Adding a custom instruction"
+deepl style-rules add-instruction "${STYLE_ID}" tone "Be formal and courteous"
+echo
+
+# 5. List custom instructions
+echo "5. Listing custom instructions"
+deepl style-rules instructions "${STYLE_ID}"
+echo
+
+# 6. Update the instruction's prompt
+echo "6. Updating the instruction's prompt"
+deepl style-rules update-instruction "${STYLE_ID}" tone "Be warm but professional"
+echo
+
+# 7. Remove the instruction (skipping confirmation for the script)
+echo "7. Removing the instruction"
+deepl style-rules remove-instruction "${STYLE_ID}" tone --yes
+echo
+
+# 8. Rename the rule
+echo "8. Renaming the rule"
+deepl style-rules update "${STYLE_ID}" --name "Example Corporate (renamed)"
+echo
+
+# 9. Delete the rule (cleanup trap will also catch this but we do it explicitly)
+echo "9. Deleting the rule"
+deepl style-rules delete "${STYLE_ID}" --yes
+STYLE_ID=""
+echo
+
+echo "=== Example 35 complete ==="
diff --git a/examples/36-write-extended-languages.sh b/examples/36-write-extended-languages.sh
new file mode 100755
index 0000000..f01a74c
--- /dev/null
+++ b/examples/36-write-extended-languages.sh
@@ -0,0 +1,63 @@
+#!/bin/bash
+# Example 36: Write — extended language coverage
+# Demonstrates JA/KO/ZH/zh-Hans target languages and
+# tone / style applied to ES/IT/FR/PT variants.
+
+set -e
+
+echo "=== DeepL CLI Example 36: Write — Extended Language Coverage ==="
+echo
+
+if ! deepl auth show &>/dev/null; then
+  echo "❌ Error: API key not configured"
+  echo "Run: deepl auth set-key YOUR_API_KEY"
+  exit 1
+fi
+
+echo "✓ API key configured"
+echo
+
+# CJK targets
+echo "1. Japanese target"
+deepl write "この文章を改善してください。" --lang ja
+echo
+
+echo "2. Korean target"
+deepl write "이 문장을 개선해 주세요." --lang ko
+echo
+
+echo "3. Simplified Chinese target (zh)"
+deepl write "请改进这句话。" --lang zh
+echo
+
+echo "4. Simplified Chinese target (zh-Hans)"
+deepl write "请改进这句话。" --lang zh-Hans
+echo
+
+# Tone / style on Romance variants
+echo "5. Spanish + business style"
+deepl write "Quiero comprar su producto." --lang es --style business
+echo
+
+echo "6. Italian + casual style"
+deepl write "Voglio comprare questo prodotto." --lang it --style casual
+echo
+
+echo "7. French + academic style"
+deepl write "Les résultats montrent une corrélation." --lang fr --style academic
+echo
+
+echo "8. Portuguese (Brazil) + friendly tone"
+deepl write "Podemos ajudar com isso." --lang pt-BR --tone friendly
+echo
+
+echo "9. Portuguese (Portugal) + confident tone"
+deepl write "Vamos entregar no prazo." --lang pt-PT --tone confident
+echo
+
+# Auto-detect round-trip for a CJK input
+echo "10. Auto-detect (no --lang) rephrase of a Korean input"
+deepl write "이 문장을 개선해 주세요."
+echo
+
+echo "=== Example 36 complete ==="
diff --git a/examples/README.md b/examples/README.md
index 3913271..e8fee41 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -22,6 +22,7 @@ This directory contains practical, real-world examples of using the DeepL CLI.
 
 **Write:**
 - [Writing Enhancement](./13-write.sh) - Using DeepL Write API for grammar, style, and tone improvement
+- [Write — Extended Languages](./36-write-extended-languages.sh) - JA/KO/ZH targets and tone/style on ES/IT/FR/PT variants
 
 **Voice:**
 - [Voice Translation](./14-voice.sh) - Real-time speech translation via the Voice API
@@ -47,6 +48,7 @@ This directory contains practical, real-world examples of using the DeepL CLI.
 - [Custom Config Files](./20-custom-config-files.sh) - Using multiple configuration files for different projects
 - [Cache Management](./21-cache.sh) - Working with the translation cache
 - [Style Rules](./22-style-rules.sh) - Listing and using pre-configured style rules for consistent translations
+- [Style Rules — CRUD](./35-style-rules-crud.sh) - End-to-end style-rules lifecycle: create, update rules, manage custom instructions, delete
 
 ### Information
 
diff --git a/examples/run-all.sh b/examples/run-all.sh
index 2373262..7e34200 100755
--- a/examples/run-all.sh
+++ b/examples/run-all.sh
@@ -62,6 +62,7 @@ EXAMPLES=(
   "12-cost-transparency.sh"
   # Core Commands - Write
   "13-write.sh"
+  "36-write-extended-languages.sh"
   # Core Commands - Voice
   "14-voice.sh"
   # Resources
@@ -80,6 +81,7 @@ EXAMPLES=(
   "20-custom-config-files.sh"
   "21-cache.sh"
   "22-style-rules.sh"
+  "35-style-rules-crud.sh"
   # Information
   "23-usage-monitoring.sh"
   "24-languages.sh"
@@ -113,6 +115,7 @@ if [ "$FAST_MODE" = true ]; then
     "12-cost-transparency.sh"
     # Core Commands - Write
     "13-write.sh"
+    "36-write-extended-languages.sh"
     # Core Commands - Voice
     "14-voice.sh"
     # Resources
@@ -128,6 +131,7 @@ if [ "$FAST_MODE" = true ]; then
     "20-custom-config-files.sh"
     "21-cache.sh"
     "22-style-rules.sh"
+    "35-style-rules-crud.sh"
     # Information
     "23-usage-monitoring.sh"
     "24-languages.sh"
diff --git a/jest.config.js b/jest.config.js
index 9ac0582..6a3bbf4 100644
--- a/jest.config.js
+++ b/jest.config.js
@@ -85,6 +85,19 @@ export default {
   resetMocks: true,
   restoreMocks: true,
 
+  // KNOWN BENIGN WARNING: jest emits "A worker process has failed to exit
+  // gracefully" at the end of every full-suite run. Stack traces lead to six
+  // `nock(...).replyWithError(...)` test sites in deepl-client.test.ts and
+  // three integration files. The leak is in nock v14 + @mswjs/interceptors:
+  // each replyWithError call constructs a synthetic Node IncomingMessage
+  // that is never drained, leaving an HTTPINCOMINGMESSAGE handle pinned in
+  // the worker. The affected tests all PASS — only the orphaned handles
+  // trigger the warning. `forceExit: true` does not suppress it (the warning
+  // fires from the worker, not the main process, before forceExit applies),
+  // and `--runInBand` eliminates it but is 5× slower. Fixing upstream
+  // (nock/mswjs) is out of scope. Run `npm run test:debug` to audit for
+  // any NEW leak source beyond the six known replyWithError sites.
+
   // Verbose output
   verbose: true,
 };
diff --git a/package.json b/package.json
index b6c7b2e..99de896 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "deepl-cli",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Next-generation CLI for DeepL translation and writing enhancement",
   "type": "module",
   "main": "dist/index.js",
@@ -31,6 +31,7 @@
     "test:unit": "jest tests/unit",
     "test:integration": "jest tests/integration",
     "test:e2e": "jest tests/e2e",
+    "test:debug": "jest --runInBand --detectOpenHandles --forceExit=false",
     "examples": "bash examples/run-all.sh",
     "examples:fast": "bash examples/run-all.sh --fast",
     "lint": "eslint 'src/**/*.ts' 'tests/**/*.ts'",
diff --git a/src/api/deepl-client.ts b/src/api/deepl-client.ts
index b3edf83..b9b7b4e 100644
--- a/src/api/deepl-client.ts
+++ b/src/api/deepl-client.ts
@@ -19,6 +19,12 @@ import {
   StyleRule,
   StyleRuleDetailed,
   StyleRulesListOptions,
+  CreateStyleRuleOptions,
+  UpdateStyleRuleOptions,
+  CustomInstruction,
+  ConfiguredRules,
+  CreateCustomInstructionOptions,
+  UpdateCustomInstructionOptions,
   AdminApiKey,
   AdminUsageOptions,
   AdminUsageReport,
@@ -220,6 +226,49 @@ export class DeepLClient {
     return this.styleRulesClient.getStyleRules(options);
   }
 
+  async createStyleRule(options: CreateStyleRuleOptions): Promise<StyleRule> {
+    return this.styleRulesClient.createStyleRule(options);
+  }
+
+  async getStyleRule(styleId: string, detailed = false): Promise<StyleRule | StyleRuleDetailed> {
+    return this.styleRulesClient.getStyleRule(styleId, detailed);
+  }
+
+  async updateStyleRule(styleId: string, options: UpdateStyleRuleOptions): Promise<StyleRule> {
+    return this.styleRulesClient.updateStyleRule(styleId, options);
+  }
+
+  async deleteStyleRule(styleId: string): Promise<void> {
+    return this.styleRulesClient.deleteStyleRule(styleId);
+  }
+
+  async replaceConfiguredRules(styleId: string, rules: ConfiguredRules): Promise<StyleRuleDetailed> {
+    return this.styleRulesClient.replaceConfiguredRules(styleId, rules);
+  }
+
+  async createCustomInstruction(
+    styleId: string,
+    options: CreateCustomInstructionOptions,
+  ): Promise<CustomInstruction> {
+    return this.styleRulesClient.createCustomInstruction(styleId, options);
+  }
+
+  async getCustomInstruction(styleId: string, label: string): Promise<CustomInstruction> {
+    return this.styleRulesClient.getCustomInstruction(styleId, label);
+  }
+
+  async updateCustomInstruction(
+    styleId: string,
+    label: string,
+    options: UpdateCustomInstructionOptions,
+  ): Promise<CustomInstruction> {
+    return this.styleRulesClient.updateCustomInstruction(styleId, label, options);
+  }
+
+  async deleteCustomInstruction(styleId: string, label: string): Promise<void> {
+    return this.styleRulesClient.deleteCustomInstruction(styleId, label);
+  }
+
   async listApiKeys(): Promise<AdminApiKey[]> {
     return this.adminClient.listApiKeys();
   }
diff --git a/src/api/http-client.ts b/src/api/http-client.ts
index 579a953..785e3e8 100644
--- a/src/api/http-client.ts
+++ b/src/api/http-client.ts
@@ -12,6 +12,7 @@ import {
 } from '../utils/errors.js';
 import { Logger } from '../utils/logger.js';
 import { errorMessage } from '../utils/error-message.js';
+import { sanitizeForTerminal } from '../utils/control-chars.js';
 import { VERSION } from '../version.js';
 
 export const USER_AGENT = `deepl-cli/${VERSION} node/${process.versions.node}`;
@@ -367,7 +368,13 @@ export class HttpClient {
       const responseData = error.response?.data as
         | { message?: string }
         | undefined;
-      const message = responseData?.message ?? error.message;
+      // Sanitize the server-returned message before any interpolation into
+      // user-facing error strings. Defense-in-depth against a malicious or
+      // buggy server scribbling ANSI escape codes / control chars on the
+      // user's terminal. Mirrors the TMS-client hardening (sync-pagq.7).
+      // Coalesce to '' before sanitizing — some axios error shapes have no
+      // `.message` field, and sanitizeForTerminal expects a string.
+      const message = sanitizeForTerminal(responseData?.message ?? error.message ?? '');
 
       switch (status) {
         case 403:
diff --git a/src/api/style-rules-client.ts b/src/api/style-rules-client.ts
index fa70d0c..b63eb7a 100644
--- a/src/api/style-rules-client.ts
+++ b/src/api/style-rules-client.ts
@@ -1,5 +1,62 @@
 import { HttpClient, DeepLClientOptions } from './http-client.js';
-import { StyleRule, StyleRuleDetailed, StyleRulesListOptions } from '../types/index.js';
+import {
+  StyleRule,
+  StyleRuleDetailed,
+  StyleRulesListOptions,
+  CreateStyleRuleOptions,
+  UpdateStyleRuleOptions,
+  CustomInstruction,
+  ConfiguredRules,
+  CreateCustomInstructionOptions,
+  UpdateCustomInstructionOptions,
+} from '../types/index.js';
+import { ValidationError } from '../utils/errors.js';
+
+interface CustomInstructionWireShape {
+  id?: string;
+  label: string;
+  prompt: string;
+  source_language?: string;
+}
+
+function mapCustomInstruction(wire: CustomInstructionWireShape): CustomInstruction {
+  return {
+    ...(wire.id !== undefined && { id: wire.id }),
+    label: wire.label,
+    prompt: wire.prompt,
+    ...(wire.source_language !== undefined && { sourceLanguage: wire.source_language }),
+  };
+}
+
+interface StyleRuleWireShape {
+  style_id: string;
+  name: string;
+  language: string;
+  version: number;
+  creation_time: string;
+  updated_time: string;
+  configured_rules?: ConfiguredRules;
+  custom_instructions?: CustomInstructionWireShape[];
+}
+
+function mapStyleRule(wire: StyleRuleWireShape): StyleRule {
+  return {
+    styleId: wire.style_id,
+    name: wire.name,
+    language: wire.language,
+    version: wire.version,
+    creationTime: wire.creation_time,
+    updatedTime: wire.updated_time,
+  };
+}
+
+function mapStyleRuleDetailed(wire: StyleRuleWireShape): StyleRuleDetailed {
+  return {
+    ...mapStyleRule(wire),
+    configuredRules: wire.configured_rules ?? {},
+    customInstructions: (wire.custom_instructions ?? []).map(mapCustomInstruction),
+  };
+}
 
 export class StyleRulesClient extends HttpClient {
   constructor(apiKey: string, options: DeepLClientOptions = {}) {
@@ -24,45 +81,166 @@ export class StyleRulesClient extends HttpClient {
     }
 
     const response = await this.makeJsonRequest<{
-      style_rules: Array<{
-        style_id: string;
-        name: string;
-        language: string;
-        version: number;
-        creation_time: string;
-        updated_time: string;
-        configured_rules?: string[];
-        custom_instructions?: Array<{
-          label: string;
-          prompt: string;
-          source_language?: string;
-        }>;
-      }>;
+      style_rules: StyleRuleWireShape[];
     }>('GET', '/v3/style_rules', params);
 
-    return response.style_rules.map((rule) => {
-      const base: StyleRule = {
-        styleId: rule.style_id,
-        name: rule.name,
-        language: rule.language,
-        version: rule.version,
-        creationTime: rule.creation_time,
-        updatedTime: rule.updated_time,
-      };
-
-      if (options.detailed && rule.configured_rules && rule.custom_instructions) {
-        return {
-          ...base,
-          configuredRules: rule.configured_rules,
-          customInstructions: rule.custom_instructions.map(ci => ({
-            label: ci.label,
-            prompt: ci.prompt,
-            ...(ci.source_language && { sourceLanguage: ci.source_language }),
-          })),
-        } as StyleRuleDetailed;
-      }
-
-      return base;
-    });
+    return response.style_rules.map((rule) =>
+      options.detailed ? mapStyleRuleDetailed(rule) : mapStyleRule(rule),
+    );
+  }
+
+  async createStyleRule(options: CreateStyleRuleOptions): Promise<StyleRule> {
+    const body: Record<string, unknown> = {
+      name: options.name,
+      language: options.language,
+    };
+    if (options.configuredRules !== undefined) {
+      body['configured_rules'] = options.configuredRules;
+    }
+    if (options.customInstructions !== undefined) {
+      body['custom_instructions'] = options.customInstructions.map(ci => ({
+        label: ci.label,
+        prompt: ci.prompt,
+        ...(ci.sourceLanguage && { source_language: ci.sourceLanguage }),
+      }));
+    }
+    const wire = await this.makeJsonRequest<StyleRuleWireShape>(
+      'POST',
+      '/v3/style_rules',
+      body,
+    );
+    return mapStyleRule(wire);
+  }
+
+  async getStyleRule(styleId: string, detailed = false): Promise<StyleRule | StyleRuleDetailed> {
+    const params: Record<string, string | number | boolean> = {};
+    if (detailed) {
+      params['detailed'] = true;
+    }
+    const wire = await this.makeJsonRequest<StyleRuleWireShape>(
+      'GET',
+      `/v3/style_rules/${encodeURIComponent(styleId)}`,
+      undefined,
+      params,
+    );
+    return detailed ? mapStyleRuleDetailed(wire) : mapStyleRule(wire);
+  }
+
+  async updateStyleRule(styleId: string, options: UpdateStyleRuleOptions): Promise<StyleRule> {
+    const body: Record<string, unknown> = {};
+    if (options.name !== undefined) {
+      body['name'] = options.name;
+    }
+    if (options.configuredRules !== undefined) {
+      body['configured_rules'] = options.configuredRules;
+    }
+    if (options.customInstructions !== undefined) {
+      body['custom_instructions'] = options.customInstructions.map(ci => ({
+        label: ci.label,
+        prompt: ci.prompt,
+        ...(ci.sourceLanguage && { source_language: ci.sourceLanguage }),
+      }));
+    }
+    const wire = await this.makeJsonRequest<StyleRuleWireShape>(
+      'PATCH',
+      `/v3/style_rules/${encodeURIComponent(styleId)}`,
+      body,
+    );
+    return mapStyleRule(wire);
+  }
+
+  async deleteStyleRule(styleId: string): Promise<void> {
+    await this.makeJsonRequest<void>(
+      'DELETE',
+      `/v3/style_rules/${encodeURIComponent(styleId)}`,
+    );
+  }
+
+  async replaceConfiguredRules(styleId: string, rules: ConfiguredRules): Promise<StyleRuleDetailed> {
+    // The PUT endpoint at /configured_rules takes the rules dict as the entire body
+    // (no `configured_rules` outer wrapper). The wrapper is only used on POST /v3/style_rules
+    // and PATCH /v3/style_rules/{id} where the body has multiple top-level fields.
+    const wire = await this.makeJsonRequest<StyleRuleWireShape>(
+      'PUT',
+      `/v3/style_rules/${encodeURIComponent(styleId)}/configured_rules`,
+      rules as unknown as Record<string, unknown>,
+    );
+    return mapStyleRuleDetailed(wire);
+  }
+
+  async createCustomInstruction(
+    styleId: string,
+    options: CreateCustomInstructionOptions,
+  ): Promise<CustomInstruction> {
+    const body: Record<string, unknown> = {
+      label: options.label,
+      prompt: options.prompt,
+    };
+    if (options.sourceLanguage !== undefined) {
+      body['source_language'] = options.sourceLanguage;
+    }
+    const wire = await this.makeJsonRequest<CustomInstructionWireShape>(
+      'POST',
+      `/v3/style_rules/${encodeURIComponent(styleId)}/custom_instructions`,
+      body,
+    );
+    return mapCustomInstruction(wire);
+  }
+
+  /**
+   * Resolve a custom-instruction's server-assigned id from its user-facing label.
+   * The DeepL API's per-instruction endpoints (`GET`/`PUT`/`DELETE`
+   * `/custom_instructions/{instruction_id}`) take the UUID, but users address
+   * instructions by label. This helper does the lookup via a detailed
+   * `getStyleRule`. Throws ValidationError if no instruction with that label exists.
+   */
+  private async resolveInstructionId(styleId: string, label: string): Promise<string> {
+    const detailed = await this.getStyleRule(styleId, true) as StyleRuleDetailed;
+    const found = detailed.customInstructions.find(ci => ci.label === label);
+    if (!found?.id) {
+      throw new ValidationError(
+        `No custom instruction with label "${label}" found on style rule ${styleId}.`,
+      );
+    }
+    return found.id;
+  }
+
+  async getCustomInstruction(styleId: string, label: string): Promise<CustomInstruction> {
+    const instructionId = await this.resolveInstructionId(styleId, label);
+    const wire = await this.makeJsonRequest<CustomInstructionWireShape>(
+      'GET',
+      `/v3/style_rules/${encodeURIComponent(styleId)}/custom_instructions/${encodeURIComponent(instructionId)}`,
+    );
+    return mapCustomInstruction(wire);
+  }
+
+  async updateCustomInstruction(
+    styleId: string,
+    label: string,
+    options: UpdateCustomInstructionOptions,
+  ): Promise<CustomInstruction> {
+    const instructionId = await this.resolveInstructionId(styleId, label);
+    // The PUT body requires `label` even though `instruction_id` appears in the URL path.
+    const body: Record<string, unknown> = { label };
+    if (options.prompt !== undefined) {
+      body['prompt'] = options.prompt;
+    }
+    if (options.sourceLanguage !== undefined) {
+      body['source_language'] = options.sourceLanguage;
+    }
+    const wire = await this.makeJsonRequest<CustomInstructionWireShape>(
+      'PUT',
+      `/v3/style_rules/${encodeURIComponent(styleId)}/custom_instructions/${encodeURIComponent(instructionId)}`,
+      body,
+    );
+    return mapCustomInstruction(wire);
+  }
+
+  async deleteCustomInstruction(styleId: string, label: string): Promise<void> {
+    const instructionId = await this.resolveInstructionId(styleId, label);
+    await this.makeJsonRequest<void>(
+      'DELETE',
+      `/v3/style_rules/${encodeURIComponent(styleId)}/custom_instructions/${encodeURIComponent(instructionId)}`,
+    );
   }
 }
diff --git a/src/api/write-client.ts b/src/api/write-client.ts
index 27a3fab..594d37e 100644
--- a/src/api/write-client.ts
+++ b/src/api/write-client.ts
@@ -1,6 +1,6 @@
 import { HttpClient, DeepLClientOptions } from './http-client.js';
 import { WriteOptions, WriteImprovement } from '../types/index.js';
-import { NetworkError } from '../utils/errors.js';
+import { NetworkError, ValidationError } from '../utils/errors.js';
 
 interface DeepLWriteResponse {
   improvements: Array<{
@@ -52,7 +52,16 @@ export class WriteClient extends HttpClient {
         detectedSourceLanguage: improvement.detected_source_language,
       }));
     } catch (error) {
-      throw this.handleError(error);
+      const translated = this.handleError(error);
+      if (
+        translated instanceof ValidationError &&
+        (options.writingStyle !== undefined || options.tone !== undefined)
+      ) {
+        throw new ValidationError(
+          `${translated.message} See docs/API.md for supported target language / style / tone combinations.`
+        );
+      }
+      throw translated;
     }
   }
 }
diff --git a/src/cli/commands/cache.ts b/src/cli/commands/cache.ts
index 3b919cc..22d6e67 100644
--- a/src/cli/commands/cache.ts
+++ b/src/cli/commands/cache.ts
@@ -3,8 +3,10 @@
  * Manages translation cache
  */
 
+import Table from 'cli-table3';
 import { CacheService } from '../../storage/cache.js';
 import { ConfigService } from '../../storage/config.js';
+import { isColorEnabled } from '../../utils/formatters.js';
 
 interface CacheStats {
   entries: number;
@@ -74,4 +76,31 @@ export class CacheCommand {
       `Size: ${totalSizeMB} MB / ${maxSizeMB} MB (${percentUsed}% used)`,
     ].join('\n');
   }
+
+  /** Format cache statistics as a cli-table3 table. */
+  formatStatsTable(stats: CacheStats): string {
+    const totalSizeMB = (stats.totalSize / (1024 * 1024)).toFixed(2);
+    const maxSizeMB = (stats.maxSize / (1024 * 1024)).toFixed(2);
+    const percentUsed = stats.maxSize > 0
+      ? ((stats.totalSize / stats.maxSize) * 100).toFixed(1)
+      : '0.0';
+    const colorDisabled = !isColorEnabled();
+
+    const table = new Table({
+      head: ['Metric', 'Value'],
+      colWidths: [16, 28],
+      wordWrap: true,
+      ...(colorDisabled && { style: { head: [], border: [] } }),
+    });
+
+    table.push(
+      ['Status', stats.enabled ? 'enabled' : 'disabled'],
+      ['Entries', String(stats.entries)],
+      ['Used', `${totalSizeMB} MB`],
+      ['Limit', `${maxSizeMB} MB`],
+      ['Usage', `${percentUsed}%`],
+    );
+
+    return table.toString();
+  }
 }
diff --git a/src/cli/commands/languages.ts b/src/cli/commands/languages.ts
index 2f0fca8..7079fc0 100644
--- a/src/cli/commands/languages.ts
+++ b/src/cli/commands/languages.ts
@@ -1,10 +1,12 @@
 import chalk from 'chalk';
+import Table from 'cli-table3';
 import type { LanguagesService } from '../../services/languages.js';
 import { LanguageInfo } from '../../api/deepl-client.js';
 import {
   getSourceLanguages as getRegistrySourceLanguages,
   getTargetLanguages as getRegistryTargetLanguages,
 } from '../../data/language-registry.js';
+import { isColorEnabled } from '../../utils/formatters.js';
 
 export interface LanguageDisplayEntry {
   code: string;
@@ -127,4 +129,45 @@ export class LanguagesCommand {
 
     return `${sourcePart}\n\n${targetPart}`;
   }
+
+  /** Format a single language list (source or target) as a cli-table3 table. */
+  formatLanguagesTable(languages: LanguageInfo[], type: 'source' | 'target'): string {
+    const entries = languages.length === 0 && !this.service.hasClient()
+      ? this.getRegistryLanguages(type)
+      : this.mergeWithRegistry(languages, type);
+
+    const header = type === 'source' ? 'Source Languages' : 'Target Languages';
+    if (entries.length === 0) {
+      return `${header}: (no languages available)`;
+    }
+
+    const showFormality = type === 'target' && entries.some(e => e.supportsFormality !== undefined);
+    const head = showFormality
+      ? ['Code', 'Name', 'Category', 'Formality']
+      : ['Code', 'Name', 'Category'];
+    const colWidths = showFormality ? [10, 30, 12, 13] : [10, 36, 12];
+    const colorDisabled = !isColorEnabled();
+
+    const table = new Table({
+      head,
+      colWidths,
+      wordWrap: true,
+      ...(colorDisabled && { style: { head: [], border: [] } }),
+    });
+
+    for (const entry of entries) {
+      const row: string[] = [entry.code, entry.name, entry.category];
+      if (showFormality) {
+        row.push(entry.supportsFormality ? 'yes' : '—');
+      }
+      table.push(row);
+    }
+
+    return `${header}:\n${table.toString()}`;
+  }
+
+  /** Format both source and target language tables joined by a blank line. */
+  formatAllLanguagesTable(sourceLanguages: LanguageInfo[], targetLanguages: LanguageInfo[]): string {
+    return `${this.formatLanguagesTable(sourceLanguages, 'source')}\n\n${this.formatLanguagesTable(targetLanguages, 'target')}`;
+  }
 }
diff --git a/src/cli/commands/register-cache.ts b/src/cli/commands/register-cache.ts
index 3fa7e05..eeb30d9 100644
--- a/src/cli/commands/register-cache.ts
+++ b/src/cli/commands/register-cache.ts
@@ -36,6 +36,13 @@ Examples:
             const stats = await cacheCommand.stats();
             if (options.format === 'json') {
               Logger.output(JSON.stringify(stats, null, 2));
+            } else if (options.format === 'table') {
+              if (!process.stdout.isTTY) {
+                Logger.warn('--format table is not supported in non-TTY output; falling back to plain text');
+                Logger.output(cacheCommand.formatStats(stats));
+              } else {
+                Logger.output(cacheCommand.formatStatsTable(stats));
+              }
             } else {
               Logger.output(cacheCommand.formatStats(stats));
             }
diff --git a/src/cli/commands/register-languages.ts b/src/cli/commands/register-languages.ts
index f762829..876fe33 100644
--- a/src/cli/commands/register-languages.ts
+++ b/src/cli/commands/register-languages.ts
@@ -26,6 +26,7 @@ Examples:
   $ deepl languages --source
   $ deepl languages --target
   $ deepl languages --format json
+  $ deepl languages --format table
 `)
     .action(async (options: { source?: boolean; target?: boolean; format?: string }) => {
       try {
@@ -57,25 +58,37 @@ Examples:
             ]);
             Logger.output(JSON.stringify({ source: sourceLanguages, target: targetLanguages }, null, 2));
           }
-        } else {
-          let output: string;
+          return;
+        }
 
-          if (options.source && !options.target) {
-            const sourceLanguages = await languagesCommand.getSourceLanguages();
-            output = languagesCommand.formatLanguages(sourceLanguages, 'source');
-          } else if (options.target && !options.source) {
-            const targetLanguages = await languagesCommand.getTargetLanguages();
-            output = languagesCommand.formatLanguages(targetLanguages, 'target');
-          } else {
-            const [sourceLanguages, targetLanguages] = await Promise.all([
-              languagesCommand.getSourceLanguages(),
-              languagesCommand.getTargetLanguages(),
-            ]);
-            output = languagesCommand.formatAllLanguages(sourceLanguages, targetLanguages);
-          }
+        const useTable = options.format === 'table';
+        if (useTable && !process.stdout.isTTY) {
+          Logger.warn('--format table is not supported in non-TTY output; falling back to plain text');
+        }
+        const wantTable = useTable && process.stdout.isTTY;
 
-          Logger.output(output);
+        let output: string;
+        if (options.source && !options.target) {
+          const sourceLanguages = await languagesCommand.getSourceLanguages();
+          output = wantTable
+            ? languagesCommand.formatLanguagesTable(sourceLanguages, 'source')
+            : languagesCommand.formatLanguages(sourceLanguages, 'source');
+        } else if (options.target && !options.source) {
+          const targetLanguages = await languagesCommand.getTargetLanguages();
+          output = wantTable
+            ? languagesCommand.formatLanguagesTable(targetLanguages, 'target')
+            : languagesCommand.formatLanguages(targetLanguages, 'target');
+        } else {
+          const [sourceLanguages, targetLanguages] = await Promise.all([
+            languagesCommand.getSourceLanguages(),
+            languagesCommand.getTargetLanguages(),
+          ]);
+          output = wantTable
+            ? languagesCommand.formatAllLanguagesTable(sourceLanguages, targetLanguages)
+            : languagesCommand.formatAllLanguages(sourceLanguages, targetLanguages);
         }
+
+        Logger.output(output);
       } catch (error) {
         handleError(error);
       }
diff --git a/src/cli/commands/register-style-rules.ts b/src/cli/commands/register-style-rules.ts
index dc6119f..2cc4a69 100644
--- a/src/cli/commands/register-style-rules.ts
+++ b/src/cli/commands/register-style-rules.ts
@@ -1,7 +1,51 @@
 import { Command, Option } from 'commander';
+import chalk from 'chalk';
 import { Logger } from '../../utils/logger.js';
+import { ValidationError } from '../../utils/errors.js';
+import type { ConfiguredRules, CreateCustomInstructionOptions, UpdateCustomInstructionOptions } from '../../types/index.js';
 import { createStyleRulesCommand, type CreateDeepLClient } from './service-factory.js';
 
+/**
+ * Parse `--rules` into the configured-rules dictionary the API expects:
+ * a two-level object of category → setting → value.
+ * Example: `--rules '{"punctuation":{"quotation_mark":"use_guillemets"}}'`
+ */
+function parseRulesArg(input: string): ConfiguredRules {
+  const trimmed = input.trim();
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch (error) {
+    throw new ValidationError(`--rules JSON is malformed: ${(error as Error).message}`);
+  }
+
+  if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+    throw new ValidationError(
+      '--rules must be a JSON object of category → settings, e.g. \'{"punctuation":{"quotation_mark":"use_guillemets"}}\'',
+    );
+  }
+
+  const result: ConfiguredRules = {};
+  for (const [category, settings] of Object.entries(parsed as Record<string, unknown>)) {
+    if (typeof settings !== 'object' || settings === null || Array.isArray(settings)) {
+      throw new ValidationError(
+        `--rules category "${category}" must map to an object of setting → value`,
+      );
+    }
+    const inner: Record<string, string> = {};
+    for (const [key, value] of Object.entries(settings as Record<string, unknown>)) {
+      if (typeof value !== 'string') {
+        throw new ValidationError(
+          `--rules setting "${category}.${key}" must be a string`,
+        );
+      }
+      inner[key] = value;
+    }
+    result[category] = inner;
+  }
+  return result;
+}
+
 export function registerStyleRules(
   program: Command,
   deps: {
@@ -19,7 +63,17 @@ Examples:
   $ deepl style-rules list
   $ deepl style-rules list --detailed
   $ deepl style-rules list --format json
+  $ deepl style-rules list --format table
   $ deepl style-rules list --page 2 --page-size 10
+  $ deepl style-rules create --name "Corporate" --language en
+  $ deepl style-rules show sr-abc123 --detailed
+  $ deepl style-rules update sr-abc123 --name "Renamed"
+  $ deepl style-rules update sr-abc123 --rules '{"punctuation":{"quotation_mark":"use_guillemets"}}'
+  $ deepl style-rules delete sr-abc123 --yes
+  $ deepl style-rules instructions sr-abc123
+  $ deepl style-rules add-instruction sr-abc123 tone "Be formal"
+  $ deepl style-rules update-instruction sr-abc123 tone "Be friendlier"
+  $ deepl style-rules remove-instruction sr-abc123 tone --yes
 `)
     .addCommand(
       new Command('list')
@@ -27,7 +81,7 @@ Examples:
         .option('--detailed', 'Show detailed information including configured rules and custom instructions')
         .option('--page <number>', 'Page number for pagination', parseInt)
         .option('--page-size <number>', 'Number of results per page (1-25)', parseInt)
-        .addOption(new Option('--format <format>', 'Output format').choices(['text', 'json']).default('text'))
+        .addOption(new Option('--format <format>', 'Output format').choices(['text', 'json', 'table']).default('text'))
         .action(async (options: {
           detailed?: boolean;
           page?: number;
@@ -45,6 +99,13 @@ Examples:
 
             if (options.format === 'json') {
               Logger.output(styleRulesCommand.formatStyleRulesJson(rules));
+            } else if (options.format === 'table') {
+              if (!process.stdout.isTTY) {
+                Logger.warn('--format table is not supported in non-TTY output; falling back to plain text');
+                Logger.output(styleRulesCommand.formatStyleRulesList(rules));
+              } else {
+                Logger.output(styleRulesCommand.formatStyleRulesTable(rules));
+              }
             } else {
               Logger.output(styleRulesCommand.formatStyleRulesList(rules));
             }
@@ -52,5 +113,256 @@ Examples:
             handleError(error);
           }
         })
+    )
+    .addCommand(
+      new Command('create')
+        .description('Create a new style rule list')
+        .requiredOption('--name <name>', 'Style rule list name')
+        .requiredOption('--language <lang>', 'Target language (e.g. en, de, es)')
+        .option('--rules <json>', 'Configured rules as a JSON object of category → settings (e.g. \'{"punctuation":{"quotation_mark":"use_guillemets"}}\')')
+        .addOption(new Option('--format <format>', 'Output format').choices(['text', 'json']).default('text'))
+        .action(async (options: {
+          name: string;
+          language: string;
+          rules?: string;
+          format?: string;
+        }) => {
+          try {
+            const styleRulesCommand = await createStyleRulesCommand(createDeepLClient);
+
+            const createOpts: { name: string; language: string; configuredRules?: ConfiguredRules } = {
+              name: options.name,
+              language: options.language,
+            };
+            if (options.rules !== undefined) {
+              createOpts.configuredRules = parseRulesArg(options.rules);
+            }
+
+            const rule = await styleRulesCommand.create(createOpts);
+            if (options.format === 'json') {
+              Logger.output(styleRulesCommand.formatStyleRuleJson(rule));
+            } else {
+              Logger.success(chalk.green(`\u2713 Style rule created: ${rule.styleId}`));
+              Logger.output(styleRulesCommand.formatStyleRule(rule));
+            }
+          } catch (error) {
+            handleError(error);
+          }
+        })
+    )
+    .addCommand(
+      new Command('show')
+        .description('Show a single style rule list')
+        .argument('<id>', 'Style rule ID')
+        .option('--detailed', 'Include configured rules and custom instructions')
+        .addOption(new Option('--format <format>', 'Output format').choices(['text', 'json']).default('text'))
+        .action(async (id: string, options: { detailed?: boolean; format?: string }) => {
+          try {
+            const styleRulesCommand = await createStyleRulesCommand(createDeepLClient);
+
+            const rule = await styleRulesCommand.show(id, options.detailed ?? false);
+            if (options.format === 'json') {
+              Logger.output(styleRulesCommand.formatStyleRuleJson(rule));
+            } else {
+              Logger.output(styleRulesCommand.formatStyleRule(rule));
+            }
+          } catch (error) {
+            handleError(error);
+          }
+        })
+    )
+    .addCommand(
+      new Command('update')
+        .description('Update a style rule list (rename and/or replace configured rules)')
+        .argument('<id>', 'Style rule ID')
+        .option('--name <name>', 'New name')
+        .option('--rules <json>', 'Replace configured rules with a JSON object of category → settings')
+        .addOption(new Option('--format <format>', 'Output format').choices(['text', 'json']).default('text'))
+        .action(async (id: string, options: { name?: string; rules?: string; format?: string }) => {
+          try {
+            if (options.name === undefined && options.rules === undefined) {
+              throw new ValidationError('Specify at least one of --name or --rules');
+            }
+
+            const styleRulesCommand = await createStyleRulesCommand(createDeepLClient);
+
+            if (options.name !== undefined) {
+              await styleRulesCommand.update(id, { name: options.name });
+            }
+
+            let finalRule;
+            if (options.rules !== undefined) {
+              finalRule = await styleRulesCommand.replaceRules(id, parseRulesArg(options.rules));
+            } else {
+              finalRule = await styleRulesCommand.show(id);
+            }
+
+            if (options.format === 'json') {
+              Logger.output(styleRulesCommand.formatStyleRuleJson(finalRule));
+            } else {
+              Logger.success(chalk.green(`\u2713 Style rule updated: ${id}`));
+              Logger.output(styleRulesCommand.formatStyleRule(finalRule));
+            }
+          } catch (error) {
+            handleError(error);
+          }
+        })
+    )
+    .addCommand(
+      new Command('delete')
+        .description('Delete a style rule list')
+        .argument('<id>', 'Style rule ID')
+        .option('-y, --yes', 'Skip confirmation prompt')
+        .option('--dry-run', 'Show what would be deleted without performing the operation')
+        .action(async (id: string, options: { yes?: boolean; dryRun?: boolean }) => {
+          try {
+            if (options.dryRun) {
+              Logger.output(chalk.yellow(`[dry-run] No deletions will be performed.`));
+              Logger.output(chalk.yellow(`[dry-run] Would delete style rule: "${id}"`));
+              return;
+            }
+
+            if (!options.yes) {
+              const { confirm } = await import('../../utils/confirm.js');
+              const confirmed = await confirm({ message: `Delete style rule "${id}"?` });
+              if (!confirmed) {
+                Logger.info('Aborted.');
+                return;
+              }
+            }
+
+            const styleRulesCommand = await createStyleRulesCommand(createDeepLClient);
+            await styleRulesCommand.delete(id);
+            Logger.success(chalk.green(`\u2713 Style rule deleted: ${id}`));
+          } catch (error) {
+            handleError(error);
+          }
+        })
+    )
+    .addCommand(
+      new Command('instructions')
+        .description('List custom instructions for a style rule')
+        .argument('<style-id>', 'Style rule ID')
+        .addOption(new Option('--format <format>', 'Output format').choices(['text', 'json', 'table']).default('text'))
+        .action(async (styleId: string, options: { format?: string }) => {
+          try {
+            const styleRulesCommand = await createStyleRulesCommand(createDeepLClient);
+            const instructions = await styleRulesCommand.listInstructions(styleId);
+            if (options.format === 'json') {
+              Logger.output(styleRulesCommand.formatCustomInstructionJson(instructions));
+            } else if (options.format === 'table') {
+              if (!process.stdout.isTTY) {
+                Logger.warn('--format table is not supported in non-TTY output; falling back to plain text');
+                Logger.output(styleRulesCommand.formatCustomInstructionsList(instructions));
+              } else {
+                Logger.output(styleRulesCommand.formatCustomInstructionsTable(instructions));
+              }
+            } else {
+              Logger.output(styleRulesCommand.formatCustomInstructionsList(instructions));
+            }
+          } catch (error) {
+            handleError(error);
+          }
+        })
+    )
+    .addCommand(
+      new Command('add-instruction')
+        .description('Add a custom instruction to a style rule')
+        .argument('<style-id>', 'Style rule ID')
+        .argument('<label>', 'Instruction label (unique within the style rule)')
+        .argument('<prompt>', 'Instruction prompt text')
+        .option('--source-language <lang>', 'Source language code (optional)')
+        .addOption(new Option('--format <format>', 'Output format').choices(['text', 'json']).default('text'))
+        .action(async (
+          styleId: string,
+          label: string,
+          prompt: string,
+          options: { sourceLanguage?: string; format?: string },
+        ) => {
+          try {
+            const styleRulesCommand = await createStyleRulesCommand(createDeepLClient);
+            const createOpts: CreateCustomInstructionOptions = { label, prompt };
+            if (options.sourceLanguage !== undefined) {
+              createOpts.sourceLanguage = options.sourceLanguage;
+            }
+            const instruction = await styleRulesCommand.addInstruction(styleId, createOpts);
+            if (options.format === 'json') {
+              Logger.output(styleRulesCommand.formatCustomInstructionJson(instruction));
+            } else {
+              Logger.success(chalk.green(`\u2713 Instruction added: ${instruction.label}`));
+              Logger.output(styleRulesCommand.formatCustomInstruction(instruction));
+            }
+          } catch (error) {
+            handleError(error);
+          }
+        })
+    )
+    .addCommand(
+      new Command('update-instruction')
+        .description('Update a custom instruction on a style rule')
+        .argument('<style-id>', 'Style rule ID')
+        .argument('<label>', 'Instruction label')
+        .argument('<prompt>', 'New instruction prompt text')
+        .option('--source-language <lang>', 'Source language code (optional)')
+        .addOption(new Option('--format <format>', 'Output format').choices(['text', 'json']).default('text'))
+        .action(async (
+          styleId: string,
+          label: string,
+          prompt: string,
+          options: { sourceLanguage?: string; format?: string },
+        ) => {
+          try {
+            const styleRulesCommand = await createStyleRulesCommand(createDeepLClient);
+            const updateOpts: UpdateCustomInstructionOptions = { prompt };
+            if (options.sourceLanguage !== undefined) {
+              updateOpts.sourceLanguage = options.sourceLanguage;
+            }
+            const instruction = await styleRulesCommand.updateInstruction(styleId, label, updateOpts);
+            if (options.format === 'json') {
+              Logger.output(styleRulesCommand.formatCustomInstructionJson(instruction));
+            } else {
+              Logger.success(chalk.green(`\u2713 Instruction updated: ${instruction.label}`));
+              Logger.output(styleRulesCommand.formatCustomInstruction(instruction));
+            }
+          } catch (error) {
+            handleError(error);
+          }
+        })
+    )
+    .addCommand(
+      new Command('remove-instruction')
+        .description('Remove a custom instruction from a style rule')
+        .argument('<style-id>', 'Style rule ID')
+        .argument('<label>', 'Instruction label')
+        .option('-y, --yes', 'Skip confirmation prompt')
+        .option('--dry-run', 'Show what would be removed without performing the operation')
+        .action(async (
+          styleId: string,
+          label: string,
+          options: { yes?: boolean; dryRun?: boolean },
+        ) => {
+          try {
+            if (options.dryRun) {
+              Logger.output(chalk.yellow(`[dry-run] No removals will be performed.`));
+              Logger.output(chalk.yellow(`[dry-run] Would remove instruction "${label}" from style rule "${styleId}"`));
+              return;
+            }
+
+            if (!options.yes) {
+              const { confirm } = await import('../../utils/confirm.js');
+              const confirmed = await confirm({ message: `Remove instruction "${label}" from style rule "${styleId}"?` });
+              if (!confirmed) {
+                Logger.info('Aborted.');
+                return;
+              }
+            }
+
+            const styleRulesCommand = await createStyleRulesCommand(createDeepLClient);
+            await styleRulesCommand.removeInstruction(styleId, label);
+            Logger.success(chalk.green(`\u2713 Instruction removed: ${label}`));
+          } catch (error) {
+            handleError(error);
+          }
+        })
     );
 }
diff --git a/src/cli/commands/register-usage.ts b/src/cli/commands/register-usage.ts
index 40f0b8b..7e74853 100644
--- a/src/cli/commands/register-usage.ts
+++ b/src/cli/commands/register-usage.ts
@@ -19,6 +19,7 @@ export function registerUsage(
 Examples:
   $ deepl usage
   $ deepl usage --format json
+  $ deepl usage --format table
 `)
     .action(async (options: { format?: string }) => {
       try {
@@ -27,6 +28,13 @@ Examples:
         const usage = await usageCommand.getUsage();
         if (options.format === 'json') {
           Logger.output(JSON.stringify(usage, null, 2));
+        } else if (options.format === 'table') {
+          if (!process.stdout.isTTY) {
+            Logger.warn('--format table is not supported in non-TTY output; falling back to plain text');
+            Logger.output(usageCommand.formatUsage(usage));
+          } else {
+            Logger.output(usageCommand.formatUsageTable(usage));
+          }
         } else {
           Logger.output(usageCommand.formatUsage(usage));
         }
diff --git a/src/cli/commands/register-write.ts b/src/cli/commands/register-write.ts
index 1437343..84b9de2 100644
--- a/src/cli/commands/register-write.ts
+++ b/src/cli/commands/register-write.ts
@@ -9,6 +9,10 @@ import { isNoInput } from '../../utils/confirm.js';
 import { ValidationError } from '../../utils/errors.js';
 import { createWriteCommand, type ServiceDeps } from './service-factory.js';
 
+const WRITE_LANGUAGES = ['de', 'en', 'en-GB', 'en-US', 'es', 'fr', 'it', 'ja', 'ko', 'pt', 'pt-BR', 'pt-PT', 'zh', 'zh-Hans'] as const;
+const WRITE_STYLES = ['default', 'simple', 'business', 'academic', 'casual', 'prefer_simple', 'prefer_business', 'prefer_academic', 'prefer_casual'] as const;
+const WRITE_TONES = ['default', 'enthusiastic', 'friendly', 'confident', 'diplomatic', 'prefer_enthusiastic', 'prefer_friendly', 'prefer_confident', 'prefer_diplomatic'] as const;
+
 export function registerWrite(
   program: Command,
   deps: Pick<ServiceDeps, 'createDeepLClient' | 'getConfigService' | 'getCacheService' | 'handleError'>,
@@ -20,10 +24,10 @@ export function registerWrite(
     .description('Improve text using DeepL Write API (grammar, style, tone)')
     .argument('[text]', 'Text to improve, file path, or read from stdin')
     .optionsGroup('Core Options:')
-    .option('-l, --lang <language>', 'Target language: de, en, en-GB, en-US, es, fr, it, pt, pt-BR, pt-PT (auto-detect if omitted)')
+    .option('-l, --lang <language>', `Target language: ${WRITE_LANGUAGES.join(', ')} (auto-detect if omitted)`)
     .option('--to <language>', 'Alias of --lang — accepts the same language values. Provided for muscle-memory consistency with `deepl translate --to`.')
-    .option('--style <style>', 'Writing style: default, simple, business, academic, casual, prefer_simple, prefer_business, prefer_academic, prefer_casual')
-    .option('--tone <tone>', 'Tone: default, enthusiastic, friendly, confident, diplomatic, prefer_enthusiastic, prefer_friendly, prefer_confident, prefer_diplomatic')
+    .option('--style <style>', `Writing style: ${WRITE_STYLES.join(', ')}`)
+    .option('--tone <tone>', `Tone: ${WRITE_TONES.join(', ')}`)
     .optionsGroup('Output Modes:')
     .option('-a, --alternatives', 'Show all alternative improvements')
     .option('-o, --output <file>', 'Write improved text to file')
@@ -87,19 +91,16 @@ Examples:
           text = stdinText;
         }
 
-        const validLanguages = ['de', 'en', 'en-GB', 'en-US', 'es', 'fr', 'it', 'pt', 'pt-BR', 'pt-PT'];
-        if (options.lang && !validLanguages.includes(options.lang)) {
-          throw new ValidationError(`Invalid language code: ${options.lang}. Valid options: ${validLanguages.join(', ')}`);
+        if (options.lang && !(WRITE_LANGUAGES as readonly string[]).includes(options.lang)) {
+          throw new ValidationError(`Invalid language code: ${options.lang}. Valid options: ${WRITE_LANGUAGES.join(', ')}`);
         }
 
-        const validStyles = ['default', 'simple', 'business', 'academic', 'casual', 'prefer_simple', 'prefer_business', 'prefer_academic', 'prefer_casual'];
-        if (options.style && !validStyles.includes(options.style)) {
-          throw new ValidationError(`Invalid writing style: ${options.style}. Valid options: ${validStyles.join(', ')}`);
+        if (options.style && !(WRITE_STYLES as readonly string[]).includes(options.style)) {
+          throw new ValidationError(`Invalid writing style: ${options.style}. Valid options: ${WRITE_STYLES.join(', ')}`);
         }
 
-        const validTones = ['default', 'enthusiastic', 'friendly', 'confident', 'diplomatic', 'prefer_enthusiastic', 'prefer_friendly', 'prefer_confident', 'prefer_diplomatic'];
-        if (options.tone && !validTones.includes(options.tone)) {
-          throw new ValidationError(`Invalid tone: ${options.tone}. Valid options: ${validTones.join(', ')}`);
+        if (options.tone && !(WRITE_TONES as readonly string[]).includes(options.tone)) {
+          throw new ValidationError(`Invalid tone: ${options.tone}. Valid options: ${WRITE_TONES.join(', ')}`);
         }
 
         if (options.style && options.tone) {
diff --git a/src/cli/commands/style-rules.ts b/src/cli/commands/style-rules.ts
index f2abfdf..b6f5831 100644
--- a/src/cli/commands/style-rules.ts
+++ b/src/cli/commands/style-rules.ts
@@ -3,8 +3,40 @@
  * Handles listing and displaying DeepL style rules
  */
 
+import Table from 'cli-table3';
 import type { StyleRulesService } from '../../services/style-rules.js';
-import { StyleRule, StyleRuleDetailed, StyleRulesListOptions } from '../../types/index.js';
+import {
+  StyleRule,
+  StyleRuleDetailed,
+  StyleRulesListOptions,
+  CreateStyleRuleOptions,
+  UpdateStyleRuleOptions,
+  CustomInstruction,
+  ConfiguredRules,
+  CreateCustomInstructionOptions,
+  UpdateCustomInstructionOptions,
+} from '../../types/index.js';
+import { sanitizeForTerminal } from '../../utils/control-chars.js';
+import { isColorEnabled } from '../../utils/formatters.js';
+
+/** Total leaf settings across all categories. Used as the "Rules" count column. */
+function countConfiguredRules(rules: ConfiguredRules): number {
+  return Object.values(rules).reduce((sum, group) => sum + Object.keys(group).length, 0);
+}
+
+/** Render the configured-rules dictionary as indented text lines, sanitized. */
+function renderConfiguredRulesText(rules: ConfiguredRules, lines: string[]): void {
+  if (countConfiguredRules(rules) === 0) {
+    return;
+  }
+  lines.push(`    Rules:`);
+  for (const [category, settings] of Object.entries(rules)) {
+    lines.push(`      ${sanitizeForTerminal(category)}:`);
+    for (const [key, value] of Object.entries(settings)) {
+      lines.push(`        ${sanitizeForTerminal(key)}: ${sanitizeForTerminal(value)}`);
+    }
+  }
+}
 
 /**
  * Manages DeepL style rules for controlling translation tone and style.
@@ -35,7 +67,7 @@ export class StyleRulesCommand {
     lines.push(`Found ${rules.length} style rule(s):\n`);
 
     for (const rule of rules) {
-      lines.push(`  ${rule.name}`);
+      lines.push(`  ${sanitizeForTerminal(rule.name)}`);
       lines.push(`    ID:       ${rule.styleId}`);
       lines.push(`    Language: ${rule.language}`);
       lines.push(`    Version:  ${rule.version}`);
@@ -44,14 +76,12 @@ export class StyleRulesCommand {
 
       if ('configuredRules' in rule) {
         const detailed = rule;
-        if (detailed.configuredRules.length > 0) {
-          lines.push(`    Rules:    ${detailed.configuredRules.join(', ')}`);
-        }
+        renderConfiguredRulesText(detailed.configuredRules, lines);
         if (detailed.customInstructions.length > 0) {
           lines.push(`    Custom Instructions:`);
           for (const instruction of detailed.customInstructions) {
             const langSuffix = instruction.sourceLanguage ? ` [${instruction.sourceLanguage}]` : '';
-            lines.push(`      - ${instruction.label}: ${instruction.prompt}${langSuffix}`);
+            lines.push(`      - ${sanitizeForTerminal(instruction.label)}: ${sanitizeForTerminal(instruction.prompt)}${langSuffix}`);
           }
         }
       }
@@ -66,4 +96,169 @@ export class StyleRulesCommand {
   formatStyleRulesJson(rules: (StyleRule | StyleRuleDetailed)[]): string {
     return JSON.stringify(rules, null, 2);
   }
+
+  /** Format style rules as a cli-table3 table. Includes rules/instructions counts when detailed. */
+  formatStyleRulesTable(rules: (StyleRule | StyleRuleDetailed)[]): string {
+    if (rules.length === 0) {
+      return 'No style rules found.';
+    }
+
+    const detailed = rules.some(r => 'configuredRules' in r);
+    const head = detailed
+      ? ['Name', 'ID', 'Language', 'Version', 'Updated', 'Rules', 'Instructions']
+      : ['Name', 'ID', 'Language', 'Version', 'Updated'];
+    const colWidths = detailed ? [24, 18, 10, 9, 22, 7, 14] : [30, 20, 10, 9, 22];
+    const colorDisabled = !isColorEnabled();
+
+    const table = new Table({
+      head,
+      colWidths,
+      wordWrap: true,
+      ...(colorDisabled && { style: { head: [], border: [] } }),
+    });
+
+    for (const rule of rules) {
+      const row: string[] = [
+        sanitizeForTerminal(rule.name),
+        rule.styleId,
+        rule.language,
+        String(rule.version),
+        rule.updatedTime,
+      ];
+      if (detailed) {
+        if ('configuredRules' in rule) {
+          row.push(String(countConfiguredRules(rule.configuredRules)));
+          row.push(String(rule.customInstructions.length));
+        } else {
+          row.push('—');
+          row.push('—');
+        }
+      }
+      table.push(row);
+    }
+
+    return table.toString();
+  }
+
+  /** Format a list of custom instructions as a cli-table3 table. */
+  formatCustomInstructionsTable(instructions: CustomInstruction[]): string {
+    if (instructions.length === 0) {
+      return 'No custom instructions found.';
+    }
+
+    const colorDisabled = !isColorEnabled();
+    const table = new Table({
+      head: ['Label', 'Prompt', 'Source'],
+      colWidths: [20, 50, 10],
+      wordWrap: true,
+      ...(colorDisabled && { style: { head: [], border: [] } }),
+    });
+
+    for (const instruction of instructions) {
+      table.push([
+        sanitizeForTerminal(instruction.label),
+        sanitizeForTerminal(instruction.prompt),
+        instruction.sourceLanguage ?? '—',
+      ]);
+    }
+
+    return table.toString();
+  }
+
+  async create(options: CreateStyleRuleOptions): Promise<StyleRule> {
+    return this.service.createStyleRule(options);
+  }
+
+  async show(styleId: string, detailed = false): Promise<StyleRule | StyleRuleDetailed> {
+    return this.service.getStyleRule(styleId, detailed);
+  }
+
+  async update(styleId: string, options: UpdateStyleRuleOptions): Promise<StyleRule> {
+    return this.service.updateStyleRule(styleId, options);
+  }
+
+  async delete(styleId: string): Promise<void> {
+    return this.service.deleteStyleRule(styleId);
+  }
+
+  async replaceRules(styleId: string, rules: ConfiguredRules): Promise<StyleRuleDetailed> {
+    return this.service.replaceConfiguredRules(styleId, rules);
+  }
+
+  /** Format a single style rule for human-readable terminal output. */
+  formatStyleRule(rule: StyleRule | StyleRuleDetailed): string {
+    const lines: string[] = [];
+    lines.push(`  ${sanitizeForTerminal(rule.name)}`);
+    lines.push(`    ID:       ${rule.styleId}`);
+    lines.push(`    Language: ${rule.language}`);
+    lines.push(`    Version:  ${rule.version}`);
+    lines.push(`    Created:  ${rule.creationTime}`);
+    lines.push(`    Updated:  ${rule.updatedTime}`);
+
+    if ('configuredRules' in rule) {
+      renderConfiguredRulesText(rule.configuredRules, lines);
+      if (rule.customInstructions.length > 0) {
+        lines.push(`    Custom Instructions:`);
+        for (const instruction of rule.customInstructions) {
+          const langSuffix = instruction.sourceLanguage ? ` [${instruction.sourceLanguage}]` : '';
+          lines.push(`      - ${sanitizeForTerminal(instruction.label)}: ${sanitizeForTerminal(instruction.prompt)}${langSuffix}`);
+        }
+      }
+    }
+
+    return lines.join('\n');
+  }
+
+  /** Serialize a single style rule as pretty-printed JSON. */
+  formatStyleRuleJson(rule: StyleRule | StyleRuleDetailed): string {
+    return JSON.stringify(rule, null, 2);
+  }
+
+  async listInstructions(styleId: string): Promise<CustomInstruction[]> {
+    const rule = await this.service.getStyleRule(styleId, true);
+    return 'customInstructions' in rule ? rule.customInstructions : [];
+  }
+
+  async addInstruction(
+    styleId: string,
+    options: CreateCustomInstructionOptions,
+  ): Promise<CustomInstruction> {
+    return this.service.createCustomInstruction(styleId, options);
+  }
+
+  async updateInstruction(
+    styleId: string,
+    label: string,
+    options: UpdateCustomInstructionOptions,
+  ): Promise<CustomInstruction> {
+    return this.service.updateCustomInstruction(styleId, label, options);
+  }
+
+  async removeInstruction(styleId: string, label: string): Promise<void> {
+    return this.service.deleteCustomInstruction(styleId, label);
+  }
+
+  /** Format a single custom instruction for human-readable terminal output. */
+  formatCustomInstruction(instruction: CustomInstruction): string {
+    const langSuffix = instruction.sourceLanguage ? ` [${instruction.sourceLanguage}]` : '';
+    return `  ${sanitizeForTerminal(instruction.label)}${langSuffix}\n    ${sanitizeForTerminal(instruction.prompt)}`;
+  }
+
+  /** Format a list of custom instructions for human-readable terminal output. */
+  formatCustomInstructionsList(instructions: CustomInstruction[]): string {
+    if (instructions.length === 0) {
+      return 'No custom instructions found.';
+    }
+    const lines: string[] = [`Found ${instructions.length} custom instruction(s):`, ''];
+    for (const instruction of instructions) {
+      lines.push(this.formatCustomInstruction(instruction));
+      lines.push('');
+    }
+    return lines.join('\n').trimEnd();
+  }
+
+  /** Serialize a custom instruction or list as pretty-printed JSON. */
+  formatCustomInstructionJson(data: CustomInstruction | CustomInstruction[]): string {
+    return JSON.stringify(data, null, 2);
+  }
 }
diff --git a/src/cli/commands/usage.ts b/src/cli/commands/usage.ts
index 589f207..f98e0c8 100644
--- a/src/cli/commands/usage.ts
+++ b/src/cli/commands/usage.ts
@@ -4,8 +4,10 @@
  */
 
 import chalk from 'chalk';
+import Table from 'cli-table3';
 import type { UsageService } from '../../services/usage.js';
 import { UsageInfo } from '../../api/deepl-client.js';
+import { isColorEnabled } from '../../utils/formatters.js';
 
 export class UsageCommand {
   private service: UsageService;
@@ -137,4 +139,101 @@ export class UsageCommand {
     }
     return `${seconds}s ${ms % 1000}ms`;
   }
+
+  /** Format usage statistics as a cli-table3 table. */
+  formatUsageTable(usage: UsageInfo): string {
+    const formatNumber = (n: number): string => n.toLocaleString('en-US');
+    const pct = (count: number, limit: number): string =>
+      limit > 0 ? `${((count / limit) * 100).toFixed(1)}%` : '—';
+    const fmtLimit = (limit: number | undefined): string =>
+      limit === undefined || limit === 0 ? 'unlimited' : formatNumber(limit);
+    const colorDisabled = !isColorEnabled();
+
+    const table = new Table({
+      head: ['Resource', 'Used', 'Limit', 'Usage'],
+      colWidths: [22, 18, 18, 10],
+      wordWrap: true,
+      ...(colorDisabled && { style: { head: [], border: [] } }),
+    });
+
+    table.push([
+      'Characters',
+      formatNumber(usage.characterCount),
+      fmtLimit(usage.characterLimit),
+      pct(usage.characterCount, usage.characterLimit),
+    ]);
+
+    if (usage.accountUnitCount !== undefined) {
+      table.push([
+        'Account units',
+        formatNumber(usage.accountUnitCount),
+        fmtLimit(usage.accountUnitLimit),
+        pct(usage.accountUnitCount, usage.accountUnitLimit ?? 0),
+      ]);
+    }
+
+    if (usage.apiKeyUnitCount !== undefined) {
+      table.push([
+        'API key units',
+        formatNumber(usage.apiKeyUnitCount),
+        fmtLimit(usage.apiKeyUnitLimit),
+        pct(usage.apiKeyUnitCount, usage.apiKeyUnitLimit ?? 0),
+      ]);
+    } else if (usage.apiKeyCharacterCount !== undefined) {
+      table.push([
+        'API key characters',
+        formatNumber(usage.apiKeyCharacterCount),
+        fmtLimit(usage.apiKeyCharacterLimit),
+        pct(usage.apiKeyCharacterCount, usage.apiKeyCharacterLimit ?? 0),
+      ]);
+    }
+
+    if (usage.speechToTextMillisecondsCount !== undefined) {
+      const sttLimit = usage.speechToTextMillisecondsLimit ?? 0;
+      table.push([
+        'Speech-to-text',
+        this.formatMilliseconds(usage.speechToTextMillisecondsCount),
+        sttLimit === 0 ? 'unlimited' : this.formatMilliseconds(sttLimit),
+        pct(usage.speechToTextMillisecondsCount, sttLimit),
+      ]);
+    }
+
+    let output = table.toString();
+
+    if (usage.products && usage.products.length > 0) {
+      const productTable = new Table({
+        head: ['Product', 'Used', 'API key'],
+        colWidths: [28, 22, 22],
+        wordWrap: true,
+        ...(colorDisabled && { style: { head: [], border: [] } }),
+      });
+      for (const product of usage.products) {
+        if (product.billingUnit === 'milliseconds') {
+          productTable.push([
+            product.productType,
+            this.formatMilliseconds(product.characterCount),
+            this.formatMilliseconds(product.apiKeyCharacterCount),
+          ]);
+        } else if (product.unitCount !== undefined) {
+          const apiKeyVal = product.apiKeyUnitCount !== undefined
+            ? `${formatNumber(product.apiKeyUnitCount)} units`
+            : `${formatNumber(product.apiKeyCharacterCount)} chars`;
+          productTable.push([
+            product.productType,
+            `${formatNumber(product.unitCount)} units`,
+            apiKeyVal,
+          ]);
+        } else {
+          productTable.push([
+            product.productType,
+            `${formatNumber(product.characterCount)} chars`,
+            `${formatNumber(product.apiKeyCharacterCount)} chars`,
+          ]);
+        }
+      }
+      output = `${output}\n\nProduct Breakdown:\n${productTable.toString()}`;
+    }
+
+    return output;
+  }
 }
diff --git a/src/services/style-rules.ts b/src/services/style-rules.ts
index 084d1bd..c6f4b25 100644
--- a/src/services/style-rules.ts
+++ b/src/services/style-rules.ts
@@ -1,5 +1,15 @@
 import { DeepLClient } from '../api/deepl-client.js';
-import { StyleRule, StyleRuleDetailed, StyleRulesListOptions } from '../types/index.js';
+import {
+  StyleRule,
+  StyleRuleDetailed,
+  StyleRulesListOptions,
+  CreateStyleRuleOptions,
+  UpdateStyleRuleOptions,
+  CustomInstruction,
+  ConfiguredRules,
+  CreateCustomInstructionOptions,
+  UpdateCustomInstructionOptions,
+} from '../types/index.js';
 
 export class StyleRulesService {
   private client: DeepLClient;
@@ -11,4 +21,47 @@ export class StyleRulesService {
   async getStyleRules(options: StyleRulesListOptions = {}): Promise<(StyleRule | StyleRuleDetailed)[]> {
     return this.client.getStyleRules(options);
   }
+
+  async createStyleRule(options: CreateStyleRuleOptions): Promise<StyleRule> {
+    return this.client.createStyleRule(options);
+  }
+
+  async getStyleRule(styleId: string, detailed = false): Promise<StyleRule | StyleRuleDetailed> {
+    return this.client.getStyleRule(styleId, detailed);
+  }
+
+  async updateStyleRule(styleId: string, options: UpdateStyleRuleOptions): Promise<StyleRule> {
+    return this.client.updateStyleRule(styleId, options);
+  }
+
+  async deleteStyleRule(styleId: string): Promise<void> {
+    return this.client.deleteStyleRule(styleId);
+  }
+
+  async replaceConfiguredRules(styleId: string, rules: ConfiguredRules): Promise<StyleRuleDetailed> {
+    return this.client.replaceConfiguredRules(styleId, rules);
+  }
+
+  async createCustomInstruction(
+    styleId: string,
+    options: CreateCustomInstructionOptions,
+  ): Promise<CustomInstruction> {
+    return this.client.createCustomInstruction(styleId, options);
+  }
+
+  async getCustomInstruction(styleId: string, label: string): Promise<CustomInstruction> {
+    return this.client.getCustomInstruction(styleId, label);
+  }
+
+  async updateCustomInstruction(
+    styleId: string,
+    label: string,
+    options: UpdateCustomInstructionOptions,
+  ): Promise<CustomInstruction> {
+    return this.client.updateCustomInstruction(styleId, label, options);
+  }
+
+  async deleteCustomInstruction(styleId: string, label: string): Promise<void> {
+    return this.client.deleteCustomInstruction(styleId, label);
+  }
 }
diff --git a/src/sync/sync-utils.ts b/src/sync/sync-utils.ts
index a938e4f..2cdfe3b 100644
--- a/src/sync/sync-utils.ts
+++ b/src/sync/sync-utils.ts
@@ -1,4 +1,5 @@
 import * as path from 'path';
+import * as fs from 'fs';
 import type { ExtractedEntry, FormatRegistry, FormatParser, TranslatedEntry } from '../formats/index.js';
 import { ValidationError } from '../utils/errors.js';
 import { sanitizeForTerminal } from '../utils/control-chars.js';
@@ -69,13 +70,52 @@ export function resolveTargetPath(
   return result;
 }
 
+/**
+ * Resolve `absPath` to its symlink-followed real path.
+ *
+ * `path.resolve` performs lexical normalization only — it does not follow
+ * symlinks — so two paths that point at the same inode via different
+ * symlink chains (e.g. `/tmp` vs `/private/tmp` on macOS) compare as
+ * different strings. `fs.realpathSync` follows symlinks, but only works
+ * for paths that already exist on disk; output paths typically don't.
+ *
+ * This helper handles the output-path case by walking up to the closest
+ * existing ancestor, realpath'ing that, and re-appending the unresolved
+ * tail. If no ancestor exists (rare — implies a path on a missing volume)
+ * it falls back to the lexically-resolved path.
+ */
+function realpathOrAncestor(absPath: string): string {
+  let current = path.resolve(absPath);
+  const tail: string[] = [];
+  while (true) {
+    try {
+      const real = fs.realpathSync(current);
+      return tail.length > 0 ? path.join(real, ...tail) : real;
+    } catch {
+      const parent = path.dirname(current);
+      if (parent === current) {
+        return path.resolve(absPath);
+      }
+      tail.unshift(path.basename(current));
+      current = parent;
+    }
+  }
+}
+
 /**
  * Verify that an absolute path stays within the project root.
  * Throws ValidationError if path escapes.
+ *
+ * Both sides are resolved through `realpathOrAncestor` so symlinks are
+ * followed before the containment check. Without that, a project rooted
+ * under a symlinked directory (the common macOS case where `/tmp` is a
+ * symlink to `/private/tmp`) would reject paths the user typed in their
+ * unresolved form. Symlink-based escapes (a symlink inside the project
+ * pointing outside) are now also caught.
  */
 export function assertPathWithinRoot(absPath: string, projectRoot: string): void {
-  const resolvedRoot = path.resolve(projectRoot);
-  const resolvedPath = path.resolve(absPath);
+  const resolvedRoot = realpathOrAncestor(projectRoot);
+  const resolvedPath = realpathOrAncestor(absPath);
   if (!resolvedPath.startsWith(resolvedRoot + path.sep) && resolvedPath !== resolvedRoot) {
     throw new ValidationError(`Target path escapes project root: ${sanitizeForTerminal(absPath)}`);
   }
diff --git a/src/types/api.ts b/src/types/api.ts
index 93ad15d..1f4f20b 100644
--- a/src/types/api.ts
+++ b/src/types/api.ts
@@ -48,9 +48,13 @@ export type WriteLanguage =
   | 'es'
   | 'fr'
   | 'it'
+  | 'ja'
+  | 'ko'
   | 'pt'
   | 'pt-BR'
-  | 'pt-PT';
+  | 'pt-PT'
+  | 'zh'
+  | 'zh-Hans';
 
 export type WritingStyle =
   | 'default'
@@ -148,13 +152,23 @@ export interface StyleRule {
 }
 
 export interface CustomInstruction {
+  /** Server-assigned UUID. Present on responses; not sent on create. Used as the URL path segment for get/update/delete. */
+  id?: string;
   label: string;
   prompt: string;
   sourceLanguage?: string;
 }
 
+/**
+ * Configured rules for a style rule list. The DeepL API models this as a
+ * two-level dictionary: category → setting → value. Example for fr-CA:
+ *   { "punctuation": { "quotation_mark": "use_guillemets" } }
+ * Empty rules are represented as `{}`.
+ */
+export type ConfiguredRules = Record<string, Record<string, string>>;
+
 export interface StyleRuleDetailed extends StyleRule {
-  configuredRules: string[];
+  configuredRules: ConfiguredRules;
   customInstructions: CustomInstruction[];
 }
 
@@ -164,6 +178,30 @@ export interface StyleRulesListOptions {
   pageSize?: number;
 }
 
+export interface CreateStyleRuleOptions {
+  name: string;
+  language: string;
+  configuredRules?: ConfiguredRules;
+  customInstructions?: CustomInstruction[];
+}
+
+export interface UpdateStyleRuleOptions {
+  name?: string;
+  configuredRules?: ConfiguredRules;
+  customInstructions?: CustomInstruction[];
+}
+
+export interface CreateCustomInstructionOptions {
+  label: string;
+  prompt: string;
+  sourceLanguage?: string;
+}
+
+export interface UpdateCustomInstructionOptions {
+  prompt?: string;
+  sourceLanguage?: string;
+}
+
 // Admin API Types
 
 export interface AdminApiKey {
diff --git a/tests/e2e/cli-style-rules.e2e.test.ts b/tests/e2e/cli-style-rules.e2e.test.ts
index 90b0251..fd2b341 100644
--- a/tests/e2e/cli-style-rules.e2e.test.ts
+++ b/tests/e2e/cli-style-rules.e2e.test.ts
@@ -38,4 +38,75 @@ describe('Style Rules Command E2E', () => {
       expect(output).toContain('--format');
     });
   });
+
+  describe('style-rules create --help', () => {
+    it('should show create subcommand options', () => {
+      const output = runCLI('style-rules create --help');
+      expect(output).toContain('--name');
+      expect(output).toContain('--language');
+      expect(output).toContain('--rules');
+      expect(output).toContain('--format');
+    });
+  });
+
+  describe('style-rules show --help', () => {
+    it('should show show subcommand options', () => {
+      const output = runCLI('style-rules show --help');
+      expect(output).toContain('--detailed');
+      expect(output).toContain('--format');
+      expect(output).toMatch(/<id>|id/);
+    });
+  });
+
+  describe('style-rules update --help', () => {
+    it('should show update subcommand options', () => {
+      const output = runCLI('style-rules update --help');
+      expect(output).toContain('--name');
+      expect(output).toContain('--rules');
+    });
+  });
+
+  describe('style-rules delete --help', () => {
+    it('should show delete subcommand options', () => {
+      const output = runCLI('style-rules delete --help');
+      expect(output).toContain('--yes');
+      expect(output).toContain('--dry-run');
+    });
+  });
+
+  describe('style-rules instructions --help', () => {
+    it('should show instructions subcommand', () => {
+      const output = runCLI('style-rules instructions --help');
+      expect(output).toContain('--format');
+      expect(output).toMatch(/<style-id>|style-id/);
+    });
+  });
+
+  describe('style-rules add-instruction --help', () => {
+    it('should show add-instruction subcommand', () => {
+      const output = runCLI('style-rules add-instruction --help');
+      expect(output).toMatch(/<style-id>|style-id/);
+      expect(output).toMatch(/<label>|label/);
+      expect(output).toMatch(/<prompt>|prompt/);
+      expect(output).toContain('--source-language');
+    });
+  });
+
+  describe('style-rules update-instruction --help', () => {
+    it('should show update-instruction subcommand', () => {
+      const output = runCLI('style-rules update-instruction --help');
+      expect(output).toMatch(/<style-id>|style-id/);
+      expect(output).toMatch(/<label>|label/);
+      expect(output).toMatch(/<prompt>|prompt/);
+      expect(output).toContain('--source-language');
+    });
+  });
+
+  describe('style-rules remove-instruction --help', () => {
+    it('should show remove-instruction subcommand', () => {
+      const output = runCLI('style-rules remove-instruction --help');
+      expect(output).toContain('--yes');
+      expect(output).toContain('--dry-run');
+    });
+  });
 });
diff --git a/tests/e2e/cli-write.e2e.test.ts b/tests/e2e/cli-write.e2e.test.ts
index 3bea8b7..fa02c6e 100644
--- a/tests/e2e/cli-write.e2e.test.ts
+++ b/tests/e2e/cli-write.e2e.test.ts
@@ -55,6 +55,38 @@ describe('Write Command E2E', () => {
       }
     });
 
+    it('should accept --lang ja without validation error', () => {
+      try {
+        execSync('deepl write "test" --lang ja', { encoding: 'utf-8', stdio: 'pipe' });
+      } catch (error: any) {
+        expect(error.status).not.toBe(6);
+      }
+    });
+
+    it('should accept --lang ko without validation error', () => {
+      try {
+        execSync('deepl write "test" --lang ko', { encoding: 'utf-8', stdio: 'pipe' });
+      } catch (error: any) {
+        expect(error.status).not.toBe(6);
+      }
+    });
+
+    it('should accept --lang zh without validation error', () => {
+      try {
+        execSync('deepl write "test" --lang zh', { encoding: 'utf-8', stdio: 'pipe' });
+      } catch (error: any) {
+        expect(error.status).not.toBe(6);
+      }
+    });
+
+    it('should accept --lang zh-Hans without validation error', () => {
+      try {
+        execSync('deepl write "test" --lang zh-Hans', { encoding: 'utf-8', stdio: 'pipe' });
+      } catch (error: any) {
+        expect(error.status).not.toBe(6);
+      }
+    });
+
     it('should reject combining --style and --tone', () => {
       expect.assertions(1);
       try {
diff --git a/tests/helpers/mock-factories.ts b/tests/helpers/mock-factories.ts
index 30c53e1..2b28504 100644
--- a/tests/helpers/mock-factories.ts
+++ b/tests/helpers/mock-factories.ts
@@ -77,6 +77,28 @@ function deepLClientDefaults(): MockShape<DeepLClient> {
     downloadDocument: jest.fn().mockResolvedValue(Buffer.alloc(0)),
     improveText: jest.fn().mockResolvedValue([]),
     getStyleRules: jest.fn().mockResolvedValue([]),
+    createStyleRule: jest.fn().mockResolvedValue({
+      styleId: 'mock-id', name: 'mock', language: 'en', version: 1,
+      creationTime: 'c', updatedTime: 'u',
+    }),
+    getStyleRule: jest.fn().mockResolvedValue({
+      styleId: 'mock-id', name: 'mock', language: 'en', version: 1,
+      creationTime: 'c', updatedTime: 'u',
+    }),
+    updateStyleRule: jest.fn().mockResolvedValue({
+      styleId: 'mock-id', name: 'mock', language: 'en', version: 2,
+      creationTime: 'c', updatedTime: 'u',
+    }),
+    deleteStyleRule: jest.fn().mockResolvedValue(undefined),
+    replaceConfiguredRules: jest.fn().mockResolvedValue({
+      styleId: 'mock-id', name: 'mock', language: 'en', version: 2,
+      creationTime: 'c', updatedTime: 'u',
+      configuredRules: {}, customInstructions: [],
+    }),
+    createCustomInstruction: jest.fn().mockResolvedValue({ label: 'mock', prompt: 'mock' }),
+    getCustomInstruction: jest.fn().mockResolvedValue({ label: 'mock', prompt: 'mock' }),
+    updateCustomInstruction: jest.fn().mockResolvedValue({ label: 'mock', prompt: 'mock' }),
+    deleteCustomInstruction: jest.fn().mockResolvedValue(undefined),
     listApiKeys: jest.fn().mockResolvedValue([]),
     createApiKey: jest.fn().mockResolvedValue({ keyId: '', label: '', creationTime: '', isDeactivated: false }),
     deactivateApiKey: jest.fn().mockResolvedValue(undefined),
@@ -336,6 +358,28 @@ export function createMockUsageService(
 function styleRulesServiceDefaults(): MockShape<StyleRulesService> {
   return {
     getStyleRules: jest.fn().mockResolvedValue([]),
+    createStyleRule: jest.fn().mockResolvedValue({
+      styleId: 'mock-id', name: 'mock', language: 'en', version: 1,
+      creationTime: 'c', updatedTime: 'u',
+    }),
+    getStyleRule: jest.fn().mockResolvedValue({
+      styleId: 'mock-id', name: 'mock', language: 'en', version: 1,
+      creationTime: 'c', updatedTime: 'u',
+    }),
+    updateStyleRule: jest.fn().mockResolvedValue({
+      styleId: 'mock-id', name: 'mock', language: 'en', version: 2,
+      creationTime: 'c', updatedTime: 'u',
+    }),
+    deleteStyleRule: jest.fn().mockResolvedValue(undefined),
+    replaceConfiguredRules: jest.fn().mockResolvedValue({
+      styleId: 'mock-id', name: 'mock', language: 'en', version: 2,
+      creationTime: 'c', updatedTime: 'u',
+      configuredRules: {}, customInstructions: [],
+    }),
+    createCustomInstruction: jest.fn().mockResolvedValue({ label: 'mock', prompt: 'mock' }),
+    getCustomInstruction: jest.fn().mockResolvedValue({ label: 'mock', prompt: 'mock' }),
+    updateCustomInstruction: jest.fn().mockResolvedValue({ label: 'mock', prompt: 'mock' }),
+    deleteCustomInstruction: jest.fn().mockResolvedValue(undefined),
   };
 }
 
diff --git a/tests/integration/cli-style-rules.integration.test.ts b/tests/integration/cli-style-rules.integration.test.ts
index 3bf0dd7..f1b77e2 100644
--- a/tests/integration/cli-style-rules.integration.test.ts
+++ b/tests/integration/cli-style-rules.integration.test.ts
@@ -137,6 +137,137 @@ describe('Style Rules CLI Integration', () => {
         expect(output).toMatch(/API key|auth/i);
       }
     });
+
+    it('should accept create subcommand with required flags', () => {
+      try {
+        runCLI('deepl style-rules create --name Foo --language en', { stdio: 'pipe', excludeApiKey: true });
+      } catch (error: any) {
+        const output = error.stderr ?? error.stdout;
+        expect(output).not.toMatch(/unknown.*option/i);
+        expect(output).toMatch(/API key|auth/i);
+      }
+    });
+
+    it('should require --name and --language on create', () => {
+      expect.assertions(1);
+      try {
+        runCLI('deepl style-rules create', { stdio: 'pipe' });
+      } catch (error: any) {
+        const output = error.stderr ?? error.stdout;
+        expect(output).toMatch(/required.*(--name|--language)/i);
+      }
+    });
+
+    it('should accept show subcommand with positional id', () => {
+      try {
+        runCLI('deepl style-rules show sr-1', { stdio: 'pipe', excludeApiKey: true });
+      } catch (error: any) {
+        const output = error.stderr ?? error.stdout;
+        expect(output).not.toMatch(/unknown.*option/i);
+        expect(output).toMatch(/API key|auth/i);
+      }
+    });
+
+    it('should require id argument on show', () => {
+      expect.assertions(1);
+      try {
+        runCLI('deepl style-rules show', { stdio: 'pipe' });
+      } catch (error: any) {
+        const output = error.stderr ?? error.stdout;
+        expect(output).toMatch(/missing.*argument|id.*required/i);
+      }
+    });
+
+    it('should accept update subcommand with --name', () => {
+      try {
+        runCLI('deepl style-rules update sr-1 --name "New"', { stdio: 'pipe', excludeApiKey: true });
+      } catch (error: any) {
+        const output = error.stderr ?? error.stdout;
+        expect(output).not.toMatch(/unknown.*option/i);
+        expect(output).toMatch(/API key|auth/i);
+      }
+    });
+
+    it('should require --name or --rules on update (exit 6)', () => {
+      expect.assertions(1);
+      try {
+        runCLI('deepl style-rules update sr-1', { stdio: 'pipe' });
+      } catch (error: any) {
+        expect(error.status).toBe(6);
+      }
+    });
+
+    it('should accept delete --dry-run without running the deletion', () => {
+      const output = runCLI('deepl style-rules delete sr-1 --dry-run');
+      expect(output).toContain('[dry-run]');
+      expect(output).toContain('sr-1');
+    });
+
+    it('should accept instructions subcommand with positional style-id', () => {
+      try {
+        runCLI('deepl style-rules instructions sr-1', { stdio: 'pipe', excludeApiKey: true });
+      } catch (error: any) {
+        const output = error.stderr ?? error.stdout;
+        expect(output).not.toMatch(/unknown.*option/i);
+        expect(output).toMatch(/API key|auth/i);
+      }
+    });
+
+    it('should require style-id argument on instructions', () => {
+      expect.assertions(1);
+      try {
+        runCLI('deepl style-rules instructions', { stdio: 'pipe' });
+      } catch (error: any) {
+        const output = error.stderr ?? error.stdout;
+        expect(output).toMatch(/missing.*argument|style-id.*required/i);
+      }
+    });
+
+    it('should accept add-instruction with three positional args', () => {
+      try {
+        runCLI('deepl style-rules add-instruction sr-1 tone "Be formal"', { stdio: 'pipe', excludeApiKey: true });
+      } catch (error: any) {
+        const output = error.stderr ?? error.stdout;
+        expect(output).not.toMatch(/unknown.*option/i);
+        expect(output).toMatch(/API key|auth/i);
+      }
+    });
+
+    it('should require all three args on add-instruction', () => {
+      expect.assertions(1);
+      try {
+        runCLI('deepl style-rules add-instruction sr-1 tone', { stdio: 'pipe' });
+      } catch (error: any) {
+        const output = error.stderr ?? error.stdout;
+        expect(output).toMatch(/missing.*argument|prompt.*required/i);
+      }
+    });
+
+    it('should accept update-instruction with three positional args', () => {
+      try {
+        runCLI('deepl style-rules update-instruction sr-1 tone "Be friendlier"', { stdio: 'pipe', excludeApiKey: true });
+      } catch (error: any) {
+        const output = error.stderr ?? error.stdout;
+        expect(output).not.toMatch(/unknown.*option/i);
+        expect(output).toMatch(/API key|auth/i);
+      }
+    });
+
+    it('should accept remove-instruction --dry-run without running', () => {
+      const output = runCLI('deepl style-rules remove-instruction sr-1 tone --dry-run');
+      expect(output).toContain('[dry-run]');
+      expect(output).toContain('tone');
+      expect(output).toContain('sr-1');
+    });
+
+    it('should accept --source-language on add-instruction', () => {
+      try {
+        runCLI('deepl style-rules add-instruction sr-1 tone "Be formal" --source-language en', { stdio: 'pipe', excludeApiKey: true });
+      } catch (error: any) {
+        const output = error.stderr ?? error.stdout;
+        expect(output).not.toMatch(/unknown.*option.*source-language/i);
+      }
+    });
   });
 
   describe('command structure', () => {
@@ -296,7 +427,10 @@ describe('Style Rules API Integration', () => {
               version: 1,
               creation_time: '2024-01-01T00:00:00Z',
               updated_time: '2024-01-02T00:00:00Z',
-              configured_rules: ['no_passive_voice', 'short_sentences'],
+              configured_rules: {
+                voice: { passive: 'avoid' },
+                length: { max_sentence_words: '20' },
+              },
               custom_instructions: [
                 { label: 'Voice', prompt: 'Use active voice' },
                 { label: 'Length', prompt: 'Keep sentences under 20 words' },
@@ -309,10 +443,10 @@ describe('Style Rules API Integration', () => {
 
       expect(rules).toHaveLength(1);
       const rule = rules[0] as any;
-      expect(rule.configuredRules).toEqual([
-        'no_passive_voice',
-        'short_sentences',
-      ]);
+      expect(rule.configuredRules).toEqual({
+        voice: { passive: 'avoid' },
+        length: { max_sentence_words: '20' },
+      });
       expect(rule.customInstructions).toEqual([
         { label: 'Voice', prompt: 'Use active voice' },
         { label: 'Length', prompt: 'Keep sentences under 20 words' },
@@ -333,7 +467,9 @@ describe('Style Rules API Integration', () => {
               version: 1,
               creation_time: '2024-01-01T00:00:00Z',
               updated_time: '2024-01-02T00:00:00Z',
-              configured_rules: ['rule_a', 'rule_b'],
+              configured_rules: {
+                punctuation: { quotation_mark: 'use_guillemets' },
+              },
               custom_instructions: [
                 { label: 'Instruction one', prompt: 'Do this' },
                 { label: 'Instruction two', prompt: 'Do that' },
@@ -345,7 +481,8 @@ describe('Style Rules API Integration', () => {
       const rules = await styleRulesCommand.list({ detailed: true });
       const output = styleRulesCommand.formatStyleRulesList(rules);
 
-      expect(output).toContain('rule_a, rule_b');
+      expect(output).toContain('punctuation');
+      expect(output).toContain('quotation_mark: use_guillemets');
       expect(output).toContain('Instruction one');
       expect(output).toContain('Instruction two');
     });
@@ -411,7 +548,7 @@ describe('Style Rules API Integration', () => {
               version: 3,
               creation_time: '2024-01-01T00:00:00Z',
               updated_time: '2024-01-02T00:00:00Z',
-              configured_rules: ['concise'],
+              configured_rules: { brevity: { max_words: '20' } },
               custom_instructions: [{ label: 'Brevity', prompt: 'Be brief' }],
             },
           ],
@@ -426,7 +563,7 @@ describe('Style Rules API Integration', () => {
       expect(rules).toHaveLength(1);
       const rule = rules[0] as any;
       expect(rule.language).toBe('fr');
-      expect(rule.configuredRules).toEqual(['concise']);
+      expect(rule.configuredRules).toEqual({ brevity: { max_words: '20' } });
       expect(scope.isDone()).toBe(true);
     });
   });
@@ -568,7 +705,10 @@ describe('Style Rules API Integration', () => {
               version: 2,
               creation_time: '2024-03-01T00:00:00Z',
               updated_time: '2024-03-10T00:00:00Z',
-              configured_rules: ['formal_tone', 'no_contractions'],
+              configured_rules: {
+                tone: { formality: 'formal' },
+                grammar: { contractions: 'forbidden' },
+              },
               custom_instructions: [
                 { label: 'Formality', prompt: 'Always use formal language' },
               ],
@@ -580,7 +720,10 @@ describe('Style Rules API Integration', () => {
       const rule = rules[0] as any;
 
       expect(rule.styleId).toBe('test-id-002');
-      expect(rule.configuredRules).toEqual(['formal_tone', 'no_contractions']);
+      expect(rule.configuredRules).toEqual({
+        tone: { formality: 'formal' },
+        grammar: { contractions: 'forbidden' },
+      });
       expect(rule.customInstructions).toEqual([
         { label: 'Formality', prompt: 'Always use formal language' },
       ]);
@@ -660,4 +803,181 @@ describe('Style Rules API Integration', () => {
       await expect(noRetryCommand.list()).rejects.toThrow();
     });
   });
+
+  describe('CRUD invariants', () => {
+    const styleRuleWire = {
+      style_id: 'sr-new',
+      name: 'Corporate',
+      language: 'en',
+      version: 1,
+      creation_time: '2026-04-24T00:00:00Z',
+      updated_time: '2026-04-24T00:00:00Z',
+    };
+
+    it('invariant 1: create returns an id that show can retrieve (round-trip)', async () => {
+      const createScope = nock(FREE_API_URL)
+        .post('/v3/style_rules', (body) => {
+          expect(body.name).toBe('Corporate');
+          expect(body.language).toBe('en');
+          return true;
+        })
+        .reply(200, styleRuleWire);
+
+      const created = await styleRulesCommand.create({ name: 'Corporate', language: 'en' });
+      expect(created.styleId).toBe('sr-new');
+      expect(createScope.isDone()).toBe(true);
+
+      const showScope = nock(FREE_API_URL)
+        .get(`/v3/style_rules/${created.styleId}`)
+        .reply(200, styleRuleWire);
+
+      const shown = await styleRulesCommand.show(created.styleId);
+      expect(shown.styleId).toBe(created.styleId);
+      expect(shown.name).toBe(created.name);
+      expect(showScope.isDone()).toBe(true);
+    });
+
+    it('invariant 2: update → show reflects the patched fields', async () => {
+      const updateScope = nock(FREE_API_URL)
+        .patch('/v3/style_rules/sr-new', (body) => {
+          expect(body.name).toBe('Renamed');
+          return true;
+        })
+        .reply(200, { ...styleRuleWire, name: 'Renamed', version: 2 });
+
+      const updated = await styleRulesCommand.update('sr-new', { name: 'Renamed' });
+      expect(updated.name).toBe('Renamed');
+      expect(updated.version).toBe(2);
+      expect(updateScope.isDone()).toBe(true);
+
+      const showScope = nock(FREE_API_URL)
+        .get('/v3/style_rules/sr-new')
+        .reply(200, { ...styleRuleWire, name: 'Renamed', version: 2 });
+
+      const shown = await styleRulesCommand.show('sr-new');
+      expect(shown.name).toBe('Renamed');
+      expect(showScope.isDone()).toBe(true);
+    });
+
+    it('invariant 3: delete followed by show returns 404', async () => {
+      const deleteScope = nock(FREE_API_URL)
+        .delete('/v3/style_rules/sr-new')
+        .reply(204);
+
+      await expect(styleRulesCommand.delete('sr-new')).resolves.toBeUndefined();
+      expect(deleteScope.isDone()).toBe(true);
+
+      const showScope = nock(FREE_API_URL)
+        .get('/v3/style_rules/sr-new')
+        .reply(404, { message: 'Style rule not found' });
+
+      await expect(styleRulesCommand.show('sr-new')).rejects.toThrow();
+      expect(showScope.isDone()).toBe(true);
+    });
+
+    it('custom-instructions round-trip: create then get returns same shape', async () => {
+      const createScope = nock(FREE_API_URL)
+        .post('/v3/style_rules/sr-new/custom_instructions', (body) => {
+          expect(body.label).toBe('tone');
+          expect(body.prompt).toBe('Be formal');
+          return true;
+        })
+        .reply(200, { label: 'tone', prompt: 'Be formal' });
+
+      const created = await styleRulesCommand.addInstruction('sr-new', {
+        label: 'tone', prompt: 'Be formal',
+      });
+      expect(created).toEqual({ label: 'tone', prompt: 'Be formal' });
+      expect(createScope.isDone()).toBe(true);
+    });
+
+    it('custom-instructions list synthesizes from detailed getStyleRule', async () => {
+      const scope = nock(FREE_API_URL)
+        .get('/v3/style_rules/sr-new')
+        .query({ detailed: true })
+        .reply(200, {
+          ...styleRuleWire,
+          configured_rules: {},
+          custom_instructions: [
+            { label: 'tone', prompt: 'Be formal' },
+            { label: 'register', prompt: 'First person', source_language: 'en' },
+          ],
+        });
+
+      const result = await styleRulesCommand.listInstructions('sr-new');
+      expect(result).toHaveLength(2);
+      expect(result[1]?.sourceLanguage).toBe('en');
+      expect(scope.isDone()).toBe(true);
+    });
+
+    it('custom-instructions update then delete: lookup-then-act flow', async () => {
+      const instructionId = 'inst-uuid-1';
+
+      // 1. update: GET (lookup) + PUT
+      const lookupForUpdate = nock(FREE_API_URL)
+        .get('/v3/style_rules/sr-new')
+        .query({ detailed: true })
+        .reply(200, {
+          ...styleRuleWire,
+          configured_rules: {},
+          custom_instructions: [{ id: instructionId, label: 'tone', prompt: 'old' }],
+        });
+      const updateScope = nock(FREE_API_URL)
+        .put(`/v3/style_rules/sr-new/custom_instructions/${instructionId}`, (body) => {
+          expect(body.label).toBe('tone');
+          expect(body.prompt).toBe('Be friendlier');
+          return true;
+        })
+        .reply(200, { id: instructionId, label: 'tone', prompt: 'Be friendlier' });
+
+      const updated = await styleRulesCommand.updateInstruction('sr-new', 'tone', {
+        prompt: 'Be friendlier',
+      });
+      expect(updated.prompt).toBe('Be friendlier');
+      expect(lookupForUpdate.isDone()).toBe(true);
+      expect(updateScope.isDone()).toBe(true);
+
+      // 2. delete: GET (lookup) + DELETE
+      const lookupForDelete = nock(FREE_API_URL)
+        .get('/v3/style_rules/sr-new')
+        .query({ detailed: true })
+        .reply(200, {
+          ...styleRuleWire,
+          configured_rules: {},
+          custom_instructions: [{ id: instructionId, label: 'tone', prompt: 'Be friendlier' }],
+        });
+      const deleteScope = nock(FREE_API_URL)
+        .delete(`/v3/style_rules/sr-new/custom_instructions/${instructionId}`)
+        .reply(204);
+
+      await expect(styleRulesCommand.removeInstruction('sr-new', 'tone'))
+        .resolves.toBeUndefined();
+      expect(lookupForDelete.isDone()).toBe(true);
+      expect(deleteScope.isDone()).toBe(true);
+    });
+
+    it('replaceConfiguredRules: PUT returns updated detailed rule', async () => {
+      const rules = {
+        punctuation: { quotation_mark: 'use_guillemets' },
+        spelling_and_grammar: { accents: 'preserve' },
+      };
+      const scope = nock(FREE_API_URL)
+        .put('/v3/style_rules/sr-new/configured_rules', (body) => {
+          // Body is the rules dict directly — no `configured_rules` outer wrapper.
+          expect(body).toEqual(rules);
+          return true;
+        })
+        .reply(200, {
+          ...styleRuleWire,
+          version: 3,
+          configured_rules: rules,
+          custom_instructions: [],
+        });
+
+      const result = await styleRulesCommand.replaceRules('sr-new', rules);
+      expect(result.configuredRules).toEqual(rules);
+      expect(result.version).toBe(3);
+      expect(scope.isDone()).toBe(true);
+    });
+  });
 });
diff --git a/tests/integration/cli-write.integration.test.ts b/tests/integration/cli-write.integration.test.ts
index 0324d36..b441a67 100644
--- a/tests/integration/cli-write.integration.test.ts
+++ b/tests/integration/cli-write.integration.test.ts
@@ -264,6 +264,34 @@ describe('Write Command Integration', () => {
         output: 'I should like to purchase this item',
         expectedExact: undefined,
       },
+      {
+        lang: 'ja',
+        label: 'Japanese',
+        input: 'これを買いたい',
+        output: 'これを購入したいです',
+        expectedExact: undefined,
+      },
+      {
+        lang: 'ko',
+        label: 'Korean',
+        input: '이것을 사고 싶어요',
+        output: '이것을 구매하고 싶습니다',
+        expectedExact: undefined,
+      },
+      {
+        lang: 'zh',
+        label: 'Chinese',
+        input: '我想买这个',
+        output: '我希望购买这个',
+        expectedExact: undefined,
+      },
+      {
+        lang: 'zh-Hans',
+        label: 'Simplified Chinese',
+        input: '我要买这个',
+        output: '我想购买这个',
+        expectedExact: undefined,
+      },
     ])('should improve $label text', async ({ lang, input, output, expectedExact }) => {
       const targetLang = lang as WriteLanguage;
       const scope = nock(FREE_API_URL)
@@ -284,6 +312,45 @@ describe('Write Command Integration', () => {
     });
   });
 
+  describe('improve() - Styles and Tones on Romance language variants', () => {
+    it.each([
+      { lang: 'es', field: 'writing_style' as const, value: 'business' },
+      { lang: 'it', field: 'writing_style' as const, value: 'casual' },
+      { lang: 'fr', field: 'writing_style' as const, value: 'academic' },
+      { lang: 'pt', field: 'writing_style' as const, value: 'simple' },
+      { lang: 'pt-BR', field: 'writing_style' as const, value: 'business' },
+      { lang: 'pt-PT', field: 'writing_style' as const, value: 'casual' },
+      { lang: 'es', field: 'tone' as const, value: 'friendly' },
+      { lang: 'it', field: 'tone' as const, value: 'confident' },
+      { lang: 'fr', field: 'tone' as const, value: 'diplomatic' },
+      { lang: 'pt', field: 'tone' as const, value: 'enthusiastic' },
+      { lang: 'pt-BR', field: 'tone' as const, value: 'friendly' },
+      { lang: 'pt-PT', field: 'tone' as const, value: 'confident' },
+    ])('should send $field=$value with target_lang=$lang', async ({ lang, field, value }) => {
+      const targetLang = lang as WriteLanguage;
+      const scope = nock(FREE_API_URL)
+        .post('/v2/write/rephrase', (body) => {
+          expect(body.target_lang).toBe(targetLang);
+          expect(body[field]).toBe(value);
+          return true;
+        })
+        .reply(200, {
+          improvements: [{ text: 'improved', target_language: targetLang }],
+        });
+
+      const improveOptions: { targetLang: WriteLanguage; writingStyle?: WritingStyle; tone?: WriteTone } = { targetLang };
+      if (field === 'writing_style') {
+        improveOptions.writingStyle = value as WritingStyle;
+      } else {
+        improveOptions.tone = value as WriteTone;
+      }
+      const result = await writeService.improve('source text', improveOptions);
+
+      expect(result[0]?.text).toBe('improved');
+      expect(scope.isDone()).toBe(true);
+    });
+  });
+
   describe('improve() - Error Handling', () => {
     it('should throw error for empty text', async () => {
       await expect(writeService.improve('', { targetLang: 'en-US' })).rejects.toThrow(
diff --git a/tests/unit/cache-command.test.ts b/tests/unit/cache-command.test.ts
index eab8267..337e140 100644
--- a/tests/unit/cache-command.test.ts
+++ b/tests/unit/cache-command.test.ts
@@ -238,4 +238,39 @@ describe('CacheCommand', () => {
       expect(stats.entries).toBe(1000000);
     });
   });
+
+  describe('formatStatsTable', () => {
+    const stats = {
+      entries: 142,
+      totalSize: 25 * 1024 * 1024,   // 25 MB
+      maxSize: 100 * 1024 * 1024,    // 100 MB
+      enabled: true,
+    };
+
+    it('should render Metric/Value columns with all five rows', () => {
+      const result = cacheCommand.formatStatsTable(stats);
+      expect(result).toContain('Metric');
+      expect(result).toContain('Value');
+      expect(result).toContain('Status');
+      expect(result).toContain('enabled');
+      expect(result).toContain('Entries');
+      expect(result).toContain('142');
+      expect(result).toContain('Used');
+      expect(result).toContain('25.00 MB');
+      expect(result).toContain('Limit');
+      expect(result).toContain('100.00 MB');
+      expect(result).toContain('Usage');
+      expect(result).toContain('25.0%');
+    });
+
+    it('should report disabled status', () => {
+      const result = cacheCommand.formatStatsTable({ ...stats, enabled: false });
+      expect(result).toContain('disabled');
+    });
+
+    it('should report 0.0% usage when maxSize is zero', () => {
+      const result = cacheCommand.formatStatsTable({ ...stats, totalSize: 0, maxSize: 0 });
+      expect(result).toContain('0.0%');
+    });
+  });
 });
diff --git a/tests/unit/deepl-client.test.ts b/tests/unit/deepl-client.test.ts
index 68bf855..bb9ffe6 100644
--- a/tests/unit/deepl-client.test.ts
+++ b/tests/unit/deepl-client.test.ts
@@ -650,6 +650,40 @@ describe('DeepLClient', () => {
       }
     });
 
+    // Defense-in-depth: a malicious or buggy server could return a JSON body
+    // whose `message` field contains ANSI escape sequences or other terminal
+    // control characters. The HTTP client interpolates that field into
+    // user-facing error strings (`API error: ${message}`, `Server error
+    // (${status}): ${message}`); without sanitization, those bytes would
+    // print verbatim to the user's terminal. Mirrors the TMS-client guard at
+    // tests/unit/sync/tms-client.test.ts:253.
+    it('should strip ANSI escape sequences from a 4xx server message before interpolating into the thrown error', async () => {
+      const maliciousBody = { message: '\x1b[2J\x1b[0;0HCredentials stolen' };
+      nock(baseUrl).post('/v2/translate').reply(400, maliciousBody);
+
+      await expect(client.translate('Hello', { targetLang: 'es' })).rejects.toThrow(
+        expect.objectContaining({ message: expect.not.stringContaining('\x1b') }),
+      );
+    });
+
+    it('should strip ANSI escape sequences from a 5xx server message before interpolating into the thrown error', async () => {
+      const maliciousBody = { message: '\x1b[31mInternal failure\x1b[0m' };
+      nock(baseUrl).post('/v2/translate').times(4).reply(500, maliciousBody);
+
+      await expect(client.translate('Hello', { targetLang: 'es' })).rejects.toThrow(
+        expect.objectContaining({ message: expect.not.stringContaining('\x1b') }),
+      );
+    });
+
+    it('should strip bidi override codepoints from a server message', async () => {
+      const maliciousBody = { message: 'OK\u202EStolen' };
+      nock(baseUrl).post('/v2/translate').reply(400, maliciousBody);
+
+      await expect(client.translate('Hello', { targetLang: 'es' })).rejects.toThrow(
+        expect.objectContaining({ message: expect.not.stringContaining('\u202E') }),
+      );
+    });
+
     it('should throw classified QuotaError for 456, not raw AxiosError', async () => {
       nock(baseUrl)
         .post('/v2/translate')
@@ -2027,7 +2061,7 @@ describe('DeepLClient', () => {
               version: 1,
               creation_time: '2024-01-01T00:00:00Z',
               updated_time: '2024-01-02T00:00:00Z',
-              configured_rules: ['rule1', 'rule2'],
+              configured_rules: { punctuation: { quotation_mark: 'use_guillemets' } },
               custom_instructions: [
                 { label: 'Instruction 1', prompt: 'Do this', source_language: 'en' },
               ],
@@ -2039,7 +2073,7 @@ describe('DeepLClient', () => {
 
       expect(rules).toHaveLength(1);
       const detailed = rules[0] as any;
-      expect(detailed.configuredRules).toEqual(['rule1', 'rule2']);
+      expect(detailed.configuredRules).toEqual({ punctuation: { quotation_mark: 'use_guillemets' } });
       expect(detailed.customInstructions).toEqual([
         { label: 'Instruction 1', prompt: 'Do this', sourceLanguage: 'en' },
       ]);
diff --git a/tests/unit/languages-command.test.ts b/tests/unit/languages-command.test.ts
index b78d93a..112df5d 100644
--- a/tests/unit/languages-command.test.ts
+++ b/tests/unit/languages-command.test.ts
@@ -356,4 +356,51 @@ describe('LanguagesCommand', () => {
       expect(hi?.supportsFormality).toBeUndefined();
     });
   });
+
+  describe('formatLanguagesTable', () => {
+    it('should render Code/Name/Category headers and rows for source languages', () => {
+      const result = languagesCommand.formatLanguagesTable(mockSourceLanguages, 'source');
+      expect(result).toContain('Source Languages:');
+      expect(result).toContain('Code');
+      expect(result).toContain('Name');
+      expect(result).toContain('Category');
+      expect(result).toContain('German');
+    });
+
+    it('should add a Formality column when any target language reports it', () => {
+      const targets: LanguageInfo[] = [
+        { language: 'de', name: 'German', supportsFormality: true },
+        { language: 'en-us', name: 'English (American)', supportsFormality: false },
+      ];
+      const result = languagesCommand.formatLanguagesTable(targets, 'target');
+      expect(result).toContain('Target Languages:');
+      expect(result).toContain('Formality');
+      expect(result).toContain('yes');
+      expect(result).toContain('—');
+    });
+
+    it('should fall back to the registry when no client and no API languages', () => {
+      const noClientService = createMockLanguagesService({
+        hasClient: jest.fn().mockReturnValue(false),
+      });
+      const cmd = new LanguagesCommand(noClientService);
+      const result = cmd.formatLanguagesTable([], 'source');
+      // Registry has at least the core source languages — output must be a table, not the empty-state line.
+      expect(result).toContain('Source Languages:');
+      expect(result).not.toContain('(no languages available)');
+    });
+  });
+
+  describe('formatAllLanguagesTable', () => {
+    it('should join the source and target tables with a blank line', () => {
+      const result = languagesCommand.formatAllLanguagesTable(mockSourceLanguages, [
+        { language: 'de', name: 'German' },
+        { language: 'fr', name: 'French' },
+      ]);
+      expect(result).toContain('Source Languages:');
+      expect(result).toContain('Target Languages:');
+      // The two sections are separated by at least one blank line.
+      expect(result.split('\n\n').length).toBeGreaterThanOrEqual(2);
+    });
+  });
 });
diff --git a/tests/unit/register-cache-registration.test.ts b/tests/unit/register-cache-registration.test.ts
index 944b042..4b2324f 100644
--- a/tests/unit/register-cache-registration.test.ts
+++ b/tests/unit/register-cache-registration.test.ts
@@ -28,11 +28,22 @@ jest.mock('../../src/utils/logger', () => ({
 const mockCacheCommandInstance = {
   stats: jest.fn(),
   formatStats: jest.fn(),
+  formatStatsTable: jest.fn().mockReturnValue('stats-table'),
   clear: jest.fn(),
   enable: jest.fn(),
   disable: jest.fn(),
 };
 
+async function withTTY<T>(value: boolean, fn: () => Promise<T> | T): Promise<T> {
+  const original = process.stdout.isTTY;
+  Object.defineProperty(process.stdout, 'isTTY', { value, configurable: true, writable: true });
+  try {
+    return await fn();
+  } finally {
+    Object.defineProperty(process.stdout, 'isTTY', { value: original, configurable: true, writable: true });
+  }
+}
+
 jest.mock('../../src/cli/commands/cache', () => ({
   CacheCommand: jest.fn().mockImplementation(() => mockCacheCommandInstance),
 }));
@@ -96,6 +107,36 @@ describe('registerCache', () => {
       expect(Logger.output).toHaveBeenCalledWith(JSON.stringify(stats, null, 2));
       expect(mockCacheCommandInstance.formatStats).not.toHaveBeenCalled();
     });
+
+    it('should render cli-table3 output when --format table and stdout is a TTY', async () => {
+      const stats = { entries: 10, totalSize: 5000, maxSize: 1048576, enabled: true };
+      mockCacheCommandInstance.stats.mockResolvedValue(stats);
+      mockCacheCommandInstance.formatStatsTable.mockReturnValue('stats-table');
+
+      await withTTY(true, async () => {
+        await program.parseAsync(['node', 'test', 'cache', 'stats', '--format', 'table']);
+      });
+
+      expect(mockCacheCommandInstance.formatStatsTable).toHaveBeenCalledWith(stats);
+      expect(mockCacheCommandInstance.formatStats).not.toHaveBeenCalled();
+      expect(Logger.output).toHaveBeenCalledWith('stats-table');
+      expect(Logger.warn).not.toHaveBeenCalledWith(expect.stringContaining('non-TTY'));
+    });
+
+    it('should fall back to plain text with a warn when --format table in non-TTY', async () => {
+      const stats = { entries: 10, totalSize: 5000, maxSize: 1048576, enabled: true };
+      mockCacheCommandInstance.stats.mockResolvedValue(stats);
+      mockCacheCommandInstance.formatStats.mockReturnValue('plain stats');
+
+      await withTTY(false, async () => {
+        await program.parseAsync(['node', 'test', 'cache', 'stats', '--format', 'table']);
+      });
+
+      expect(mockCacheCommandInstance.formatStatsTable).not.toHaveBeenCalled();
+      expect(mockCacheCommandInstance.formatStats).toHaveBeenCalledWith(stats);
+      expect(Logger.warn).toHaveBeenCalledWith(expect.stringContaining('non-TTY'));
+      expect(Logger.output).toHaveBeenCalledWith('plain stats');
+    });
   });
 
   describe('cache clear', () => {
diff --git a/tests/unit/register-languages.test.ts b/tests/unit/register-languages.test.ts
index 2611b09..18c67b5 100644
--- a/tests/unit/register-languages.test.ts
+++ b/tests/unit/register-languages.test.ts
@@ -30,8 +30,20 @@ const mockLanguagesCommandInstance = {
   getTargetLanguages: jest.fn(),
   formatLanguages: jest.fn(),
   formatAllLanguages: jest.fn(),
+  formatLanguagesTable: jest.fn().mockReturnValue('languages-table'),
+  formatAllLanguagesTable: jest.fn().mockReturnValue('all-languages-table'),
 };
 
+async function withTTY<T>(value: boolean, fn: () => Promise<T> | T): Promise<T> {
+  const original = process.stdout.isTTY;
+  Object.defineProperty(process.stdout, 'isTTY', { value, configurable: true, writable: true });
+  try {
+    return await fn();
+  } finally {
+    Object.defineProperty(process.stdout, 'isTTY', { value: original, configurable: true, writable: true });
+  }
+}
+
 jest.mock('../../src/cli/commands/languages', () => ({
   LanguagesCommand: jest.fn().mockImplementation(() => mockLanguagesCommandInstance),
 }));
@@ -134,6 +146,53 @@ describe('registerLanguages', () => {
       const expected = JSON.stringify({ source: sources, target: targets }, null, 2);
       expect(Logger.output).toHaveBeenCalledWith(expected);
     });
+
+    it('should render cli-table3 output for all languages when --format table and stdout is a TTY', async () => {
+      const sources = [{ language: 'en', name: 'English' }];
+      const targets = [{ language: 'de', name: 'German' }];
+      mockLanguagesCommandInstance.getSourceLanguages.mockResolvedValue(sources);
+      mockLanguagesCommandInstance.getTargetLanguages.mockResolvedValue(targets);
+      mockLanguagesCommandInstance.formatAllLanguagesTable.mockReturnValue('all-languages-table');
+
+      await withTTY(true, async () => {
+        await program.parseAsync(['node', 'test', 'languages', '--format', 'table']);
+      });
+
+      expect(mockLanguagesCommandInstance.formatAllLanguagesTable).toHaveBeenCalledWith(sources, targets);
+      expect(mockLanguagesCommandInstance.formatAllLanguages).not.toHaveBeenCalled();
+      expect(Logger.output).toHaveBeenCalledWith('all-languages-table');
+      expect(Logger.warn).not.toHaveBeenCalledWith(expect.stringContaining('non-TTY'));
+    });
+
+    it('should render the source-only table when --format table --source on a TTY', async () => {
+      const sources = [{ language: 'en', name: 'English' }];
+      mockLanguagesCommandInstance.getSourceLanguages.mockResolvedValue(sources);
+      mockLanguagesCommandInstance.formatLanguagesTable.mockReturnValue('languages-table');
+
+      await withTTY(true, async () => {
+        await program.parseAsync(['node', 'test', 'languages', '--source', '--format', 'table']);
+      });
+
+      expect(mockLanguagesCommandInstance.formatLanguagesTable).toHaveBeenCalledWith(sources, 'source');
+      expect(mockLanguagesCommandInstance.formatLanguages).not.toHaveBeenCalled();
+    });
+
+    it('should fall back to plain text with a warn when --format table in non-TTY', async () => {
+      const sources = [{ language: 'en', name: 'English' }];
+      const targets = [{ language: 'de', name: 'German' }];
+      mockLanguagesCommandInstance.getSourceLanguages.mockResolvedValue(sources);
+      mockLanguagesCommandInstance.getTargetLanguages.mockResolvedValue(targets);
+      mockLanguagesCommandInstance.formatAllLanguages.mockReturnValue('plain text');
+
+      await withTTY(false, async () => {
+        await program.parseAsync(['node', 'test', 'languages', '--format', 'table']);
+      });
+
+      expect(mockLanguagesCommandInstance.formatAllLanguagesTable).not.toHaveBeenCalled();
+      expect(mockLanguagesCommandInstance.formatAllLanguages).toHaveBeenCalledWith(sources, targets);
+      expect(Logger.warn).toHaveBeenCalledWith(expect.stringContaining('non-TTY'));
+      expect(Logger.output).toHaveBeenCalledWith('plain text');
+    });
   });
 
   describe('with API key from environment', () => {
diff --git a/tests/unit/register-style-rules.test.ts b/tests/unit/register-style-rules.test.ts
new file mode 100644
index 0000000..835994a
--- /dev/null
+++ b/tests/unit/register-style-rules.test.ts
@@ -0,0 +1,621 @@
+import { Command } from 'commander';
+import { registerStyleRules } from '../../src/cli/commands/register-style-rules';
+import { createStyleRulesCommand } from '../../src/cli/commands/service-factory';
+import { Logger } from '../../src/utils/logger';
+
+jest.mock('../../src/cli/commands/service-factory', () => ({
+  createStyleRulesCommand: jest.fn(),
+}));
+
+jest.mock('../../src/utils/logger', () => ({
+  Logger: {
+    success: jest.fn(),
+    output: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+  },
+}));
+
+jest.mock('../../src/utils/confirm', () => ({
+  confirm: jest.fn(),
+}));
+
+jest.mock('chalk', () => ({
+  default: {
+    green: (t: string) => t,
+    yellow: (t: string) => t,
+  },
+  green: (t: string) => t,
+  yellow: (t: string) => t,
+}));
+
+const mockCreateStyleRulesCommand = createStyleRulesCommand as jest.MockedFunction<typeof createStyleRulesCommand>;
+
+const SAMPLE_RULE = {
+  styleId: 'sr-1',
+  name: 'Sample',
+  language: 'en',
+  version: 1,
+  creationTime: 'c',
+  updatedTime: 'u',
+};
+
+const SAMPLE_DETAILED = {
+  ...SAMPLE_RULE,
+  configuredRules: { punctuation: { quotation_mark: 'use_guillemets' } },
+  customInstructions: [{ label: 'tone', prompt: 'Be formal' }],
+};
+
+function makeProgram() {
+  const program = new Command();
+  program.exitOverride();
+  const handleError = jest.fn((error: unknown) => {
+    throw error;
+  }) as any;
+  const createDeepLClient = jest.fn();
+  registerStyleRules(program, { createDeepLClient, handleError });
+  return { program, handleError, createDeepLClient };
+}
+
+function makeMockStyleRulesCmd() {
+  return {
+    list: jest.fn().mockResolvedValue([SAMPLE_RULE]),
+    create: jest.fn().mockResolvedValue(SAMPLE_RULE),
+    show: jest.fn().mockResolvedValue(SAMPLE_RULE),
+    update: jest.fn().mockResolvedValue(SAMPLE_RULE),
+    delete: jest.fn().mockResolvedValue(undefined),
+    replaceRules: jest.fn().mockResolvedValue(SAMPLE_DETAILED),
+    listInstructions: jest.fn().mockResolvedValue([{ label: 'tone', prompt: 'Be formal' }]),
+    addInstruction: jest.fn().mockResolvedValue({ label: 'tone', prompt: 'Be formal' }),
+    updateInstruction: jest.fn().mockResolvedValue({ label: 'tone', prompt: 'Be friendlier' }),
+    removeInstruction: jest.fn().mockResolvedValue(undefined),
+    formatStyleRulesList: jest.fn().mockReturnValue('rules-list-text'),
+    formatStyleRulesJson: jest.fn().mockReturnValue('[]'),
+    formatStyleRulesTable: jest.fn().mockReturnValue('rules-list-table'),
+    formatStyleRule: jest.fn().mockReturnValue('rule-text'),
+    formatStyleRuleJson: jest.fn().mockReturnValue('{}'),
+    formatCustomInstruction: jest.fn().mockReturnValue('instruction-text'),
+    formatCustomInstructionsList: jest.fn().mockReturnValue('instructions-list-text'),
+    formatCustomInstructionsTable: jest.fn().mockReturnValue('instructions-list-table'),
+    formatCustomInstructionJson: jest.fn().mockReturnValue('{}'),
+  };
+}
+
+async function withTTY<T>(value: boolean, fn: () => Promise<T> | T): Promise<T> {
+  const original = process.stdout.isTTY;
+  Object.defineProperty(process.stdout, 'isTTY', { value, configurable: true, writable: true });
+  try {
+    return await fn();
+  } finally {
+    Object.defineProperty(process.stdout, 'isTTY', { value: original, configurable: true, writable: true });
+  }
+}
+
+describe('registerStyleRules', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('style-rules list', () => {
+    it('should list rules and output text by default', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await program.parseAsync(['node', 'test', 'style-rules', 'list']);
+
+      expect(mock.list).toHaveBeenCalled();
+      expect(mock.formatStyleRulesList).toHaveBeenCalledWith([SAMPLE_RULE]);
+      expect(Logger.output).toHaveBeenCalledWith('rules-list-text');
+    });
+
+    it('should output JSON when --format json', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await program.parseAsync(['node', 'test', 'style-rules', 'list', '--format', 'json']);
+
+      expect(mock.formatStyleRulesJson).toHaveBeenCalledWith([SAMPLE_RULE]);
+    });
+
+    it('should call handleError on failure', async () => {
+      mockCreateStyleRulesCommand.mockRejectedValue(new Error('boom'));
+      const { program, handleError } = makeProgram();
+
+      await expect(
+        program.parseAsync(['node', 'test', 'style-rules', 'list'])
+      ).rejects.toThrow('boom');
+      expect(handleError).toHaveBeenCalled();
+    });
+
+    it('should render cli-table3 output when --format table and stdout is a TTY', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await withTTY(true, async () => {
+        await program.parseAsync(['node', 'test', 'style-rules', 'list', '--format', 'table']);
+      });
+
+      expect(mock.formatStyleRulesTable).toHaveBeenCalledWith([SAMPLE_RULE]);
+      expect(mock.formatStyleRulesList).not.toHaveBeenCalled();
+      expect(Logger.output).toHaveBeenCalledWith('rules-list-table');
+      expect(Logger.warn).not.toHaveBeenCalled();
+    });
+
+    it('should fall back to plain text with a warn when --format table in non-TTY', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await withTTY(false, async () => {
+        await program.parseAsync(['node', 'test', 'style-rules', 'list', '--format', 'table']);
+      });
+
+      expect(mock.formatStyleRulesTable).not.toHaveBeenCalled();
+      expect(mock.formatStyleRulesList).toHaveBeenCalledWith([SAMPLE_RULE]);
+      expect(Logger.warn).toHaveBeenCalledWith(expect.stringContaining('non-TTY'));
+      expect(Logger.output).toHaveBeenCalledWith('rules-list-text');
+    });
+  });
+
+  describe('style-rules create', () => {
+    it('should create a rule with required flags', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await program.parseAsync(['node', 'test', 'style-rules', 'create', '--name', 'X', '--language', 'en']);
+
+      expect(mock.create).toHaveBeenCalledWith({ name: 'X', language: 'en' });
+      expect(Logger.success).toHaveBeenCalled();
+    });
+
+    it('should parse --rules as a JSON object of category → settings', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await program.parseAsync([
+        'node', 'test', 'style-rules', 'create',
+        '--name', 'X', '--language', 'en',
+        '--rules', '{"punctuation":{"quotation_mark":"use_guillemets"}}',
+      ]);
+
+      expect(mock.create).toHaveBeenCalledWith({
+        name: 'X', language: 'en',
+        configuredRules: { punctuation: { quotation_mark: 'use_guillemets' } },
+      });
+    });
+
+    it('should reject malformed --rules JSON', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program, handleError } = makeProgram();
+
+      await expect(
+        program.parseAsync([
+          'node', 'test', 'style-rules', 'create',
+          '--name', 'X', '--language', 'en', '--rules', '{garbage',
+        ])
+      ).rejects.toThrow();
+      expect(handleError).toHaveBeenCalled();
+    });
+
+    it('should reject --rules that is not a JSON object', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program, handleError } = makeProgram();
+
+      await expect(
+        program.parseAsync([
+          'node', 'test', 'style-rules', 'create',
+          '--name', 'X', '--language', 'en', '--rules', '["rule_a"]',
+        ])
+      ).rejects.toThrow();
+      expect(handleError).toHaveBeenCalledWith(
+        expect.objectContaining({ message: expect.stringContaining('JSON object of category') }),
+      );
+    });
+
+    it('should reject --rules whose category does not map to an object', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program, handleError } = makeProgram();
+
+      await expect(
+        program.parseAsync([
+          'node', 'test', 'style-rules', 'create',
+          '--name', 'X', '--language', 'en', '--rules', '{"punctuation":"wrong"}',
+        ])
+      ).rejects.toThrow();
+      expect(handleError).toHaveBeenCalledWith(
+        expect.objectContaining({ message: expect.stringContaining('category "punctuation"') }),
+      );
+    });
+
+    it('should reject --rules whose leaf value is not a string', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program, handleError } = makeProgram();
+
+      await expect(
+        program.parseAsync([
+          'node', 'test', 'style-rules', 'create',
+          '--name', 'X', '--language', 'en', '--rules', '{"x":{"y":42}}',
+        ])
+      ).rejects.toThrow();
+      expect(handleError).toHaveBeenCalledWith(
+        expect.objectContaining({ message: expect.stringContaining('"x.y"') }),
+      );
+    });
+
+    it('should output JSON when --format json', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await program.parseAsync([
+        'node', 'test', 'style-rules', 'create',
+        '--name', 'X', '--language', 'en', '--format', 'json',
+      ]);
+
+      expect(mock.formatStyleRuleJson).toHaveBeenCalledWith(SAMPLE_RULE);
+    });
+  });
+
+  describe('style-rules show', () => {
+    it('should show a rule in text format', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await program.parseAsync(['node', 'test', 'style-rules', 'show', 'sr-1']);
+
+      expect(mock.show).toHaveBeenCalledWith('sr-1', false);
+      expect(mock.formatStyleRule).toHaveBeenCalled();
+    });
+
+    it('should pass --detailed to show', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await program.parseAsync(['node', 'test', 'style-rules', 'show', 'sr-1', '--detailed']);
+
+      expect(mock.show).toHaveBeenCalledWith('sr-1', true);
+    });
+
+    it('should output JSON when --format json', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await program.parseAsync(['node', 'test', 'style-rules', 'show', 'sr-1', '--format', 'json']);
+
+      expect(mock.formatStyleRuleJson).toHaveBeenCalledWith(SAMPLE_RULE);
+    });
+
+    it('should propagate errors via handleError', async () => {
+      mockCreateStyleRulesCommand.mockRejectedValue(new Error('404'));
+      const { program, handleError } = makeProgram();
+
+      await expect(
+        program.parseAsync(['node', 'test', 'style-rules', 'show', 'missing'])
+      ).rejects.toThrow('404');
+      expect(handleError).toHaveBeenCalled();
+    });
+  });
+
+  describe('style-rules update', () => {
+    it('should update name only (PATCH branch)', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await program.parseAsync(['node', 'test', 'style-rules', 'update', 'sr-1', '--name', 'Renamed']);
+
+      expect(mock.update).toHaveBeenCalledWith('sr-1', { name: 'Renamed' });
+      expect(mock.replaceRules).not.toHaveBeenCalled();
+      expect(mock.show).toHaveBeenCalledWith('sr-1');
+    });
+
+    it('should update rules only (PUT branch)', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await program.parseAsync([
+        'node', 'test', 'style-rules', 'update', 'sr-1',
+        '--rules', '{"punctuation":{"quotation_mark":"use_guillemets"}}',
+      ]);
+
+      expect(mock.update).not.toHaveBeenCalled();
+      expect(mock.replaceRules).toHaveBeenCalledWith('sr-1', {
+        punctuation: { quotation_mark: 'use_guillemets' },
+      });
+    });
+
+    it('should run both PATCH and PUT when name and rules passed', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await program.parseAsync([
+        'node', 'test', 'style-rules', 'update', 'sr-1',
+        '--name', 'New', '--rules', '{"x":{"y":"z"}}',
+      ]);
+
+      expect(mock.update).toHaveBeenCalledWith('sr-1', { name: 'New' });
+      expect(mock.replaceRules).toHaveBeenCalledWith('sr-1', { x: { y: 'z' } });
+    });
+
+    it('should reject when neither --name nor --rules provided', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program, handleError } = makeProgram();
+
+      await expect(
+        program.parseAsync(['node', 'test', 'style-rules', 'update', 'sr-1'])
+      ).rejects.toThrow(/at least one of --name or --rules/);
+      expect(handleError).toHaveBeenCalled();
+    });
+
+    it('should output JSON when --format json', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await program.parseAsync([
+        'node', 'test', 'style-rules', 'update', 'sr-1',
+        '--name', 'X', '--format', 'json',
+      ]);
+
+      expect(mock.formatStyleRuleJson).toHaveBeenCalled();
+    });
+  });
+
+  describe('style-rules delete', () => {
+    it('should delete after --yes', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await program.parseAsync(['node', 'test', 'style-rules', 'delete', 'sr-1', '--yes']);
+
+      expect(mock.delete).toHaveBeenCalledWith('sr-1');
+      expect(Logger.success).toHaveBeenCalled();
+    });
+
+    it('should dry-run without deleting', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await program.parseAsync(['node', 'test', 'style-rules', 'delete', 'sr-1', '--dry-run']);
+
+      expect(mock.delete).not.toHaveBeenCalled();
+      expect(Logger.output).toHaveBeenCalledWith(expect.stringContaining('[dry-run]'));
+    });
+
+    it('should abort on declined confirmation', async () => {
+      const { confirm } = await import('../../src/utils/confirm');
+      (confirm as jest.Mock).mockResolvedValueOnce(false);
+
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await program.parseAsync(['node', 'test', 'style-rules', 'delete', 'sr-1']);
+
+      expect(mock.delete).not.toHaveBeenCalled();
+      expect(Logger.info).toHaveBeenCalledWith('Aborted.');
+    });
+
+    it('should delete on confirmed prompt', async () => {
+      const { confirm } = await import('../../src/utils/confirm');
+      (confirm as jest.Mock).mockResolvedValueOnce(true);
+
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await program.parseAsync(['node', 'test', 'style-rules', 'delete', 'sr-1']);
+
+      expect(mock.delete).toHaveBeenCalledWith('sr-1');
+    });
+  });
+
+  describe('style-rules instructions', () => {
+    it('should list instructions in text', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await program.parseAsync(['node', 'test', 'style-rules', 'instructions', 'sr-1']);
+
+      expect(mock.listInstructions).toHaveBeenCalledWith('sr-1');
+      expect(mock.formatCustomInstructionsList).toHaveBeenCalled();
+    });
+
+    it('should list instructions in JSON', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await program.parseAsync(['node', 'test', 'style-rules', 'instructions', 'sr-1', '--format', 'json']);
+
+      expect(mock.formatCustomInstructionJson).toHaveBeenCalled();
+    });
+
+    it('should render cli-table3 output when --format table and stdout is a TTY', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await withTTY(true, async () => {
+        await program.parseAsync(['node', 'test', 'style-rules', 'instructions', 'sr-1', '--format', 'table']);
+      });
+
+      expect(mock.formatCustomInstructionsTable).toHaveBeenCalled();
+      expect(mock.formatCustomInstructionsList).not.toHaveBeenCalled();
+      expect(Logger.output).toHaveBeenCalledWith('instructions-list-table');
+      expect(Logger.warn).not.toHaveBeenCalled();
+    });
+
+    it('should fall back to plain text with a warn when --format table in non-TTY', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await withTTY(false, async () => {
+        await program.parseAsync(['node', 'test', 'style-rules', 'instructions', 'sr-1', '--format', 'table']);
+      });
+
+      expect(mock.formatCustomInstructionsTable).not.toHaveBeenCalled();
+      expect(mock.formatCustomInstructionsList).toHaveBeenCalled();
+      expect(Logger.warn).toHaveBeenCalledWith(expect.stringContaining('non-TTY'));
+      expect(Logger.output).toHaveBeenCalledWith('instructions-list-text');
+    });
+
+    it('should propagate errors via handleError', async () => {
+      mockCreateStyleRulesCommand.mockRejectedValue(new Error('404'));
+      const { program, handleError } = makeProgram();
+
+      await expect(
+        program.parseAsync(['node', 'test', 'style-rules', 'instructions', 'sr-1'])
+      ).rejects.toThrow('404');
+      expect(handleError).toHaveBeenCalled();
+    });
+  });
+
+  describe('style-rules add-instruction', () => {
+    it('should add an instruction with label+prompt', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await program.parseAsync([
+        'node', 'test', 'style-rules', 'add-instruction', 'sr-1', 'tone', 'Be formal',
+      ]);
+
+      expect(mock.addInstruction).toHaveBeenCalledWith('sr-1', { label: 'tone', prompt: 'Be formal' });
+    });
+
+    it('should pass --source-language through', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await program.parseAsync([
+        'node', 'test', 'style-rules', 'add-instruction', 'sr-1', 'tone', 'Be formal',
+        '--source-language', 'en',
+      ]);
+
+      expect(mock.addInstruction).toHaveBeenCalledWith('sr-1', {
+        label: 'tone', prompt: 'Be formal', sourceLanguage: 'en',
+      });
+    });
+
+    it('should output JSON when --format json', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await program.parseAsync([
+        'node', 'test', 'style-rules', 'add-instruction', 'sr-1', 'tone', 'Be formal',
+        '--format', 'json',
+      ]);
+
+      expect(mock.formatCustomInstructionJson).toHaveBeenCalled();
+    });
+  });
+
+  describe('style-rules update-instruction', () => {
+    it('should update an instruction with new prompt', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await program.parseAsync([
+        'node', 'test', 'style-rules', 'update-instruction', 'sr-1', 'tone', 'Be friendlier',
+      ]);
+
+      expect(mock.updateInstruction).toHaveBeenCalledWith('sr-1', 'tone', { prompt: 'Be friendlier' });
+    });
+
+    it('should pass --source-language through', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await program.parseAsync([
+        'node', 'test', 'style-rules', 'update-instruction', 'sr-1', 'tone', 'Be friendlier',
+        '--source-language', 'en',
+      ]);
+
+      expect(mock.updateInstruction).toHaveBeenCalledWith('sr-1', 'tone', {
+        prompt: 'Be friendlier', sourceLanguage: 'en',
+      });
+    });
+
+    it('should output JSON when --format json', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await program.parseAsync([
+        'node', 'test', 'style-rules', 'update-instruction', 'sr-1', 'tone', 'New',
+        '--format', 'json',
+      ]);
+
+      expect(mock.formatCustomInstructionJson).toHaveBeenCalled();
+    });
+  });
+
+  describe('style-rules remove-instruction', () => {
+    it('should remove after --yes', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await program.parseAsync([
+        'node', 'test', 'style-rules', 'remove-instruction', 'sr-1', 'tone', '--yes',
+      ]);
+
+      expect(mock.removeInstruction).toHaveBeenCalledWith('sr-1', 'tone');
+      expect(Logger.success).toHaveBeenCalled();
+    });
+
+    it('should dry-run without removing', async () => {
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await program.parseAsync([
+        'node', 'test', 'style-rules', 'remove-instruction', 'sr-1', 'tone', '--dry-run',
+      ]);
+
+      expect(mock.removeInstruction).not.toHaveBeenCalled();
+      expect(Logger.output).toHaveBeenCalledWith(expect.stringContaining('[dry-run]'));
+    });
+
+    it('should abort on declined confirmation', async () => {
+      const { confirm } = await import('../../src/utils/confirm');
+      (confirm as jest.Mock).mockResolvedValueOnce(false);
+
+      const mock = makeMockStyleRulesCmd();
+      mockCreateStyleRulesCommand.mockResolvedValue(mock as any);
+      const { program } = makeProgram();
+
+      await program.parseAsync([
+        'node', 'test', 'style-rules', 'remove-instruction', 'sr-1', 'tone',
+      ]);
+
+      expect(mock.removeInstruction).not.toHaveBeenCalled();
+      expect(Logger.info).toHaveBeenCalledWith('Aborted.');
+    });
+  });
+});
diff --git a/tests/unit/register-usage.test.ts b/tests/unit/register-usage.test.ts
new file mode 100644
index 0000000..3383143
--- /dev/null
+++ b/tests/unit/register-usage.test.ts
@@ -0,0 +1,111 @@
+import { Command } from 'commander';
+
+jest.mock('../../src/utils/logger', () => ({
+  Logger: {
+    info: jest.fn(),
+    warn: jest.fn(),
+    success: jest.fn(),
+    output: jest.fn(),
+    error: jest.fn(),
+  },
+}));
+
+const mockUsageCommandInstance = {
+  getUsage: jest.fn(),
+  formatUsage: jest.fn().mockReturnValue('plain usage'),
+  formatUsageTable: jest.fn().mockReturnValue('usage-table'),
+};
+
+jest.mock('../../src/cli/commands/service-factory', () => ({
+  createUsageCommand: jest.fn(),
+}));
+
+import { registerUsage } from '../../src/cli/commands/register-usage';
+import { createUsageCommand } from '../../src/cli/commands/service-factory';
+import { Logger } from '../../src/utils/logger';
+
+const mockCreateUsageCommand = createUsageCommand as jest.MockedFunction<typeof createUsageCommand>;
+
+async function withTTY<T>(value: boolean, fn: () => Promise<T> | T): Promise<T> {
+  const original = process.stdout.isTTY;
+  Object.defineProperty(process.stdout, 'isTTY', { value, configurable: true, writable: true });
+  try {
+    return await fn();
+  } finally {
+    Object.defineProperty(process.stdout, 'isTTY', { value: original, configurable: true, writable: true });
+  }
+}
+
+describe('registerUsage', () => {
+  let program: Command;
+  const handleError = jest.fn() as jest.Mock & ((error: unknown) => never);
+  let createDeepLClient: jest.Mock;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockCreateUsageCommand.mockResolvedValue(mockUsageCommandInstance as any);
+    program = new Command();
+    program.exitOverride();
+    createDeepLClient = jest.fn();
+    registerUsage(program, { createDeepLClient, handleError });
+  });
+
+  it('should output formatted text by default', async () => {
+    const usage = { characterCount: 100, characterLimit: 500 };
+    mockUsageCommandInstance.getUsage.mockResolvedValue(usage);
+    mockUsageCommandInstance.formatUsage.mockReturnValue('plain usage');
+
+    await program.parseAsync(['node', 'test', 'usage']);
+
+    expect(mockUsageCommandInstance.formatUsage).toHaveBeenCalledWith(usage);
+    expect(Logger.output).toHaveBeenCalledWith('plain usage');
+  });
+
+  it('should output JSON when --format json', async () => {
+    const usage = { characterCount: 100, characterLimit: 500 };
+    mockUsageCommandInstance.getUsage.mockResolvedValue(usage);
+
+    await program.parseAsync(['node', 'test', 'usage', '--format', 'json']);
+
+    expect(Logger.output).toHaveBeenCalledWith(JSON.stringify(usage, null, 2));
+    expect(mockUsageCommandInstance.formatUsage).not.toHaveBeenCalled();
+  });
+
+  it('should render cli-table3 output when --format table and stdout is a TTY', async () => {
+    const usage = { characterCount: 100, characterLimit: 500 };
+    mockUsageCommandInstance.getUsage.mockResolvedValue(usage);
+    mockUsageCommandInstance.formatUsageTable.mockReturnValue('usage-table');
+
+    await withTTY(true, async () => {
+      await program.parseAsync(['node', 'test', 'usage', '--format', 'table']);
+    });
+
+    expect(mockUsageCommandInstance.formatUsageTable).toHaveBeenCalledWith(usage);
+    expect(mockUsageCommandInstance.formatUsage).not.toHaveBeenCalled();
+    expect(Logger.output).toHaveBeenCalledWith('usage-table');
+    expect(Logger.warn).not.toHaveBeenCalledWith(expect.stringContaining('non-TTY'));
+  });
+
+  it('should fall back to plain text with a warn when --format table in non-TTY', async () => {
+    const usage = { characterCount: 100, characterLimit: 500 };
+    mockUsageCommandInstance.getUsage.mockResolvedValue(usage);
+    mockUsageCommandInstance.formatUsage.mockReturnValue('plain usage');
+
+    await withTTY(false, async () => {
+      await program.parseAsync(['node', 'test', 'usage', '--format', 'table']);
+    });
+
+    expect(mockUsageCommandInstance.formatUsageTable).not.toHaveBeenCalled();
+    expect(mockUsageCommandInstance.formatUsage).toHaveBeenCalledWith(usage);
+    expect(Logger.warn).toHaveBeenCalledWith(expect.stringContaining('non-TTY'));
+    expect(Logger.output).toHaveBeenCalledWith('plain usage');
+  });
+
+  it('should call handleError on failure', async () => {
+    mockUsageCommandInstance.getUsage.mockRejectedValue(new Error('boom'));
+
+    await program.parseAsync(['node', 'test', 'usage']);
+
+    expect(handleError).toHaveBeenCalledWith(expect.objectContaining({ message: 'boom' }));
+  });
+});
diff --git a/tests/unit/register-write.test.ts b/tests/unit/register-write.test.ts
index c040e9a..020c14a 100644
--- a/tests/unit/register-write.test.ts
+++ b/tests/unit/register-write.test.ts
@@ -181,6 +181,17 @@ describe('registerWrite', () => {
       );
     });
 
+    it.each(['ja', 'ko', 'zh', 'zh-Hans'])('should accept new target language %s', async (lang) => {
+      mockCreateWriteCommand.mockResolvedValue(mockWriteCommand);
+      mockWriteCommand.improve.mockResolvedValue('ok');
+      await program.parseAsync(['node', 'test', 'write', 'Hello', '--lang', lang]);
+      expect(mockWriteCommand.improve).toHaveBeenCalledWith(
+        'Hello',
+        expect.objectContaining({ lang }),
+      );
+      expect(handleError).not.toHaveBeenCalled();
+    });
+
     it('should reject both --style and --tone', async () => {
       await program.parseAsync([
         'node', 'test', 'write', 'Hello', '--style', 'business', '--tone', 'friendly',
diff --git a/tests/unit/style-rules-client.test.ts b/tests/unit/style-rules-client.test.ts
index 98faafd..781ac01 100644
--- a/tests/unit/style-rules-client.test.ts
+++ b/tests/unit/style-rules-client.test.ts
@@ -4,6 +4,7 @@
  */
 
 import { StyleRulesClient } from '../../src/api/style-rules-client.js';
+import type { StyleRuleDetailed } from '../../src/types/api.js';
 import axios from 'axios';
 
 jest.mock('axios');
@@ -91,7 +92,10 @@ describe('StyleRulesClient', () => {
               version: 2,
               creation_time: '2024-01-01T00:00:00Z',
               updated_time: '2024-06-01T00:00:00Z',
-              configured_rules: ['rule_a', 'rule_b'],
+              configured_rules: {
+                punctuation: { quotation_mark: 'use_guillemets' },
+                spelling_and_grammar: { accents: 'preserve' },
+              },
               custom_instructions: [
                 { label: 'Instruction 1', prompt: 'Use formal tone' },
                 { label: 'Instruction 2', prompt: 'Short sentences', source_language: 'en' },
@@ -108,7 +112,10 @@ describe('StyleRulesClient', () => {
       expect(result).toHaveLength(1);
       const detailed = result[0] as any;
       expect(detailed.styleId).toBe('sr-2');
-      expect(detailed.configuredRules).toEqual(['rule_a', 'rule_b']);
+      expect(detailed.configuredRules).toEqual({
+        punctuation: { quotation_mark: 'use_guillemets' },
+        spelling_and_grammar: { accents: 'preserve' },
+      });
       expect(detailed.customInstructions).toHaveLength(2);
       expect(detailed.customInstructions[0].label).toBe('Instruction 1');
       expect(detailed.customInstructions[1].sourceLanguage).toBe('en');
@@ -162,4 +169,445 @@ describe('StyleRulesClient', () => {
       await expect(client.getStyleRules()).rejects.toThrow();
     });
   });
+
+  describe('createStyleRule()', () => {
+    it('should POST to /v3/style_rules with name+language and return mapped rule', async () => {
+      mockAxiosInstance.request.mockResolvedValue({
+        data: {
+          style_id: 'sr-new',
+          name: 'Corporate',
+          language: 'en',
+          version: 1,
+          creation_time: '2026-04-24T12:00:00Z',
+          updated_time: '2026-04-24T12:00:00Z',
+        },
+        status: 200,
+        headers: {},
+      });
+
+      const result = await client.createStyleRule({ name: 'Corporate', language: 'en' });
+
+      expect(result).toEqual({
+        styleId: 'sr-new',
+        name: 'Corporate',
+        language: 'en',
+        version: 1,
+        creationTime: '2026-04-24T12:00:00Z',
+        updatedTime: '2026-04-24T12:00:00Z',
+      });
+      expect(mockAxiosInstance.request).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: 'POST',
+          url: '/v3/style_rules',
+          data: expect.objectContaining({ name: 'Corporate', language: 'en' }),
+        }),
+      );
+    });
+
+    it('should serialize customInstructions with snake_case sourceLanguage', async () => {
+      mockAxiosInstance.request.mockResolvedValue({
+        data: {
+          style_id: 'sr-new', name: 'X', language: 'de', version: 1,
+          creation_time: 't', updated_time: 't',
+        },
+        status: 200, headers: {},
+      });
+
+      await client.createStyleRule({
+        name: 'X',
+        language: 'de',
+        customInstructions: [{ label: 'L', prompt: 'P', sourceLanguage: 'en' }],
+      });
+
+      const call = mockAxiosInstance.request.mock.calls[0][0];
+      expect(call.data.custom_instructions).toEqual([
+        { label: 'L', prompt: 'P', source_language: 'en' },
+      ]);
+    });
+
+    it('should propagate 400 error', async () => {
+      const axiosError = {
+        isAxiosError: true,
+        response: { status: 400, data: { message: 'Invalid language' }, headers: {} },
+        message: 'Bad request',
+      };
+      mockAxiosInstance.request.mockRejectedValue(axiosError);
+      jest.spyOn(axios, 'isAxiosError').mockReturnValue(true);
+
+      await expect(
+        client.createStyleRule({ name: 'X', language: 'xx' })
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('getStyleRule()', () => {
+    it('should GET /v3/style_rules/:id and return basic rule', async () => {
+      mockAxiosInstance.request.mockResolvedValue({
+        data: {
+          style_id: 'sr-1', name: 'One', language: 'en', version: 1,
+          creation_time: 'c', updated_time: 'u',
+        },
+        status: 200, headers: {},
+      });
+
+      const result = await client.getStyleRule('sr-1');
+
+      expect(result).toEqual({
+        styleId: 'sr-1', name: 'One', language: 'en', version: 1,
+        creationTime: 'c', updatedTime: 'u',
+      });
+      expect(mockAxiosInstance.request).toHaveBeenCalledWith(
+        expect.objectContaining({ method: 'GET', url: '/v3/style_rules/sr-1' }),
+      );
+    });
+
+    it('should return StyleRuleDetailed when detailed=true', async () => {
+      mockAxiosInstance.request.mockResolvedValue({
+        data: {
+          style_id: 'sr-2', name: 'Two', language: 'de', version: 3,
+          creation_time: 'c', updated_time: 'u',
+          configured_rules: { punctuation: { quotation_mark: 'use_guillemets' } },
+          custom_instructions: [{ label: 'L', prompt: 'P' }],
+        },
+        status: 200, headers: {},
+      });
+
+      const result = await client.getStyleRule('sr-2', true);
+      expect((result as StyleRuleDetailed).configuredRules).toEqual({
+        punctuation: { quotation_mark: 'use_guillemets' },
+      });
+      expect((result as StyleRuleDetailed).customInstructions).toEqual([{ label: 'L', prompt: 'P' }]);
+    });
+
+    it('should URL-encode the styleId path component', async () => {
+      mockAxiosInstance.request.mockResolvedValue({
+        data: { style_id: 'has space', name: '', language: '', version: 0, creation_time: '', updated_time: '' },
+        status: 200, headers: {},
+      });
+      await client.getStyleRule('has space');
+      expect(mockAxiosInstance.request).toHaveBeenCalledWith(
+        expect.objectContaining({ url: '/v3/style_rules/has%20space' }),
+      );
+    });
+
+    it('should propagate 404 error', async () => {
+      const axiosError = {
+        isAxiosError: true,
+        response: { status: 404, data: { message: 'Not found' }, headers: {} },
+        message: 'Not found',
+      };
+      mockAxiosInstance.request.mockRejectedValue(axiosError);
+      jest.spyOn(axios, 'isAxiosError').mockReturnValue(true);
+
+      await expect(client.getStyleRule('missing')).rejects.toThrow();
+    });
+  });
+
+  describe('updateStyleRule()', () => {
+    it('should PATCH /v3/style_rules/:id with partial body', async () => {
+      mockAxiosInstance.request.mockResolvedValue({
+        data: {
+          style_id: 'sr-1', name: 'Renamed', language: 'en', version: 2,
+          creation_time: 'c', updated_time: 'u2',
+        },
+        status: 200, headers: {},
+      });
+
+      const result = await client.updateStyleRule('sr-1', { name: 'Renamed' });
+
+      expect(result.name).toBe('Renamed');
+      expect(mockAxiosInstance.request).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: 'PATCH',
+          url: '/v3/style_rules/sr-1',
+          data: { name: 'Renamed' },
+        }),
+      );
+    });
+
+    it('should omit fields not passed', async () => {
+      mockAxiosInstance.request.mockResolvedValue({
+        data: { style_id: 'sr-1', name: 'X', language: 'en', version: 1, creation_time: 'c', updated_time: 'u' },
+        status: 200, headers: {},
+      });
+
+      await client.updateStyleRule('sr-1', {});
+      const call = mockAxiosInstance.request.mock.calls[0][0];
+      expect(call.data).toEqual({});
+    });
+
+    it('should propagate 404 error', async () => {
+      const axiosError = {
+        isAxiosError: true,
+        response: { status: 404, data: { message: 'Not found' }, headers: {} },
+        message: 'Not found',
+      };
+      mockAxiosInstance.request.mockRejectedValue(axiosError);
+      jest.spyOn(axios, 'isAxiosError').mockReturnValue(true);
+
+      await expect(client.updateStyleRule('missing', { name: 'X' })).rejects.toThrow();
+    });
+  });
+
+  describe('deleteStyleRule()', () => {
+    it('should DELETE /v3/style_rules/:id and resolve void', async () => {
+      mockAxiosInstance.request.mockResolvedValue({ data: undefined, status: 204, headers: {} });
+
+      const result = await client.deleteStyleRule('sr-1');
+
+      expect(result).toBeUndefined();
+      expect(mockAxiosInstance.request).toHaveBeenCalledWith(
+        expect.objectContaining({ method: 'DELETE', url: '/v3/style_rules/sr-1' }),
+      );
+    });
+
+    it('should propagate 404 error', async () => {
+      const axiosError = {
+        isAxiosError: true,
+        response: { status: 404, data: { message: 'Not found' }, headers: {} },
+        message: 'Not found',
+      };
+      mockAxiosInstance.request.mockRejectedValue(axiosError);
+      jest.spyOn(axios, 'isAxiosError').mockReturnValue(true);
+
+      await expect(client.deleteStyleRule('missing')).rejects.toThrow();
+    });
+  });
+
+  describe('createCustomInstruction()', () => {
+    it('should POST to /v3/style_rules/:id/custom_instructions with label+prompt and return mapped instruction', async () => {
+      mockAxiosInstance.request.mockResolvedValue({
+        data: { label: 'tone', prompt: 'Be formal' },
+        status: 200, headers: {},
+      });
+
+      const result = await client.createCustomInstruction('sr-1', { label: 'tone', prompt: 'Be formal' });
+
+      expect(result).toEqual({ label: 'tone', prompt: 'Be formal' });
+      expect(mockAxiosInstance.request).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: 'POST',
+          url: '/v3/style_rules/sr-1/custom_instructions',
+          data: { label: 'tone', prompt: 'Be formal' },
+        }),
+      );
+    });
+
+    it('should serialize sourceLanguage as source_language on the wire', async () => {
+      mockAxiosInstance.request.mockResolvedValue({
+        data: { label: 'L', prompt: 'P', source_language: 'en' },
+        status: 200, headers: {},
+      });
+
+      const result = await client.createCustomInstruction('sr-1', {
+        label: 'L', prompt: 'P', sourceLanguage: 'en',
+      });
+
+      expect(result.sourceLanguage).toBe('en');
+      const call = mockAxiosInstance.request.mock.calls[0][0];
+      expect(call.data).toEqual({ label: 'L', prompt: 'P', source_language: 'en' });
+    });
+
+    it('should propagate 400 error', async () => {
+      const axiosError = {
+        isAxiosError: true,
+        response: { status: 400, data: { message: 'Duplicate label' }, headers: {} },
+        message: 'Bad request',
+      };
+      mockAxiosInstance.request.mockRejectedValue(axiosError);
+      jest.spyOn(axios, 'isAxiosError').mockReturnValue(true);
+
+      await expect(
+        client.createCustomInstruction('sr-1', { label: 'L', prompt: 'P' })
+      ).rejects.toThrow();
+    });
+  });
+
+  // Helper: queue a "lookup" response (the GET /v3/style_rules/:id?detailed=true
+  // call that resolves a label to its server-assigned UUID), followed by the
+  // actual operation's response.
+  function queueInstructionLookup(label: string, instructionId: string): void {
+    mockAxiosInstance.request.mockResolvedValueOnce({
+      data: {
+        style_id: 'sr-1', name: 'X', language: 'en', version: 1,
+        creation_time: 'c', updated_time: 'u',
+        configured_rules: {},
+        custom_instructions: [{ id: instructionId, label, prompt: 'P' }],
+      },
+      status: 200, headers: {},
+    });
+  }
+
+  describe('getCustomInstruction()', () => {
+    it('should look up instruction id by label and GET /v3/style_rules/:id/custom_instructions/:instructionId', async () => {
+      queueInstructionLookup('tone', 'inst-uuid-1');
+      mockAxiosInstance.request.mockResolvedValueOnce({
+        data: { id: 'inst-uuid-1', label: 'tone', prompt: 'Be formal', source_language: 'en' },
+        status: 200, headers: {},
+      });
+
+      const result = await client.getCustomInstruction('sr-1', 'tone');
+
+      expect(result).toEqual({ id: 'inst-uuid-1', label: 'tone', prompt: 'Be formal', sourceLanguage: 'en' });
+      const calls = mockAxiosInstance.request.mock.calls;
+      // Second call is the actual GET on the instruction by id.
+      expect(calls[1][0]).toEqual(expect.objectContaining({
+        method: 'GET',
+        url: '/v3/style_rules/sr-1/custom_instructions/inst-uuid-1',
+      }));
+    });
+
+    it('should URL-encode both path components', async () => {
+      queueInstructionLookup('has space', 'inst id with space');
+      mockAxiosInstance.request.mockResolvedValueOnce({
+        data: { id: 'inst id with space', label: 'has space', prompt: 'P' },
+        status: 200, headers: {},
+      });
+      // The styleId is also a constructed URL — we need it to test encoding,
+      // but resolveInstructionId does its own GET which uses the raw styleId via
+      // encodeURIComponent. So passing 'sr id' should encode to 'sr%20id'.
+      // For this test we keep styleId simple ('sr-1') and verify only the
+      // instruction-id segment encoding.
+      const calls = mockAxiosInstance.request.mock.calls;
+      await client.getCustomInstruction('sr-1', 'has space');
+      const lastCall = calls[calls.length - 1][0];
+      expect(lastCall.url).toBe('/v3/style_rules/sr-1/custom_instructions/inst%20id%20with%20space');
+    });
+
+    it('should throw ValidationError when label not found', async () => {
+      mockAxiosInstance.request.mockResolvedValueOnce({
+        data: {
+          style_id: 'sr-1', name: 'X', language: 'en', version: 1,
+          creation_time: 'c', updated_time: 'u',
+          configured_rules: {},
+          custom_instructions: [{ id: 'other-uuid', label: 'register', prompt: 'P' }],
+        },
+        status: 200, headers: {},
+      });
+      await expect(client.getCustomInstruction('sr-1', 'missing'))
+        .rejects.toThrow(/No custom instruction with label "missing"/);
+    });
+  });
+
+  describe('updateCustomInstruction()', () => {
+    it('should look up id then PUT /v3/style_rules/:id/custom_instructions/:instructionId with label-required body', async () => {
+      queueInstructionLookup('tone', 'inst-uuid-1');
+      mockAxiosInstance.request.mockResolvedValueOnce({
+        data: { id: 'inst-uuid-1', label: 'tone', prompt: 'Be friendlier' },
+        status: 200, headers: {},
+      });
+
+      const result = await client.updateCustomInstruction('sr-1', 'tone', { prompt: 'Be friendlier' });
+
+      expect(result.prompt).toBe('Be friendlier');
+      // The PUT call is the second axios request.
+      // Body must include `label` (server requires it even though `instruction_id` is in the URL).
+      const putCall = mockAxiosInstance.request.mock.calls[1][0];
+      expect(putCall).toEqual(expect.objectContaining({
+        method: 'PUT',
+        url: '/v3/style_rules/sr-1/custom_instructions/inst-uuid-1',
+        data: { label: 'tone', prompt: 'Be friendlier' },
+      }));
+    });
+
+    it('should always include label and omit unset optional fields', async () => {
+      queueInstructionLookup('tone', 'inst-uuid-1');
+      mockAxiosInstance.request.mockResolvedValueOnce({
+        data: { id: 'inst-uuid-1', label: 'tone', prompt: 'x' }, status: 200, headers: {},
+      });
+      await client.updateCustomInstruction('sr-1', 'tone', {});
+      const putCall = mockAxiosInstance.request.mock.calls[1][0];
+      expect(putCall.data).toEqual({ label: 'tone' });
+    });
+
+    it('should throw ValidationError when label not found', async () => {
+      mockAxiosInstance.request.mockResolvedValueOnce({
+        data: {
+          style_id: 'sr-1', name: 'X', language: 'en', version: 1,
+          creation_time: 'c', updated_time: 'u',
+          configured_rules: {},
+          custom_instructions: [],
+        },
+        status: 200, headers: {},
+      });
+      await expect(
+        client.updateCustomInstruction('sr-1', 'missing', { prompt: 'X' })
+      ).rejects.toThrow(/No custom instruction with label "missing"/);
+    });
+  });
+
+  describe('deleteCustomInstruction()', () => {
+    it('should look up id then DELETE /v3/style_rules/:id/custom_instructions/:instructionId and resolve void', async () => {
+      queueInstructionLookup('tone', 'inst-uuid-1');
+      mockAxiosInstance.request.mockResolvedValueOnce({ data: undefined, status: 204, headers: {} });
+
+      const result = await client.deleteCustomInstruction('sr-1', 'tone');
+
+      expect(result).toBeUndefined();
+      const deleteCall = mockAxiosInstance.request.mock.calls[1][0];
+      expect(deleteCall).toEqual(expect.objectContaining({
+        method: 'DELETE',
+        url: '/v3/style_rules/sr-1/custom_instructions/inst-uuid-1',
+      }));
+    });
+
+    it('should propagate 404 error', async () => {
+      mockAxiosInstance.request.mockResolvedValueOnce({
+        data: {
+          style_id: 'sr-1', name: 'X', language: 'en', version: 1,
+          creation_time: 'c', updated_time: 'u',
+          configured_rules: {},
+          custom_instructions: [],
+        },
+        status: 200, headers: {},
+      });
+      await expect(client.deleteCustomInstruction('sr-1', 'missing'))
+        .rejects.toThrow(/No custom instruction with label "missing"/);
+    });
+  });
+
+  describe('replaceConfiguredRules()', () => {
+    it('should PUT /v3/style_rules/:id/configured_rules with the rules dictionary', async () => {
+      const rules = {
+        punctuation: { quotation_mark: 'use_guillemets' },
+        spelling_and_grammar: { accents: 'preserve' },
+      };
+      mockAxiosInstance.request.mockResolvedValue({
+        data: {
+          style_id: 'sr-1', name: 'X', language: 'en', version: 3,
+          creation_time: 'c', updated_time: 'u3',
+          configured_rules: rules,
+          custom_instructions: [],
+        },
+        status: 200, headers: {},
+      });
+
+      const result = await client.replaceConfiguredRules('sr-1', rules);
+
+      expect(result.configuredRules).toEqual(rules);
+      expect(result.version).toBe(3);
+      // Body is the rules dict directly — no `configured_rules` outer wrapper.
+      expect(mockAxiosInstance.request).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: 'PUT',
+          url: '/v3/style_rules/sr-1/configured_rules',
+          data: rules,
+        }),
+      );
+    });
+
+    it('should propagate 400 error for invalid rules', async () => {
+      const axiosError = {
+        isAxiosError: true,
+        response: { status: 400, data: { message: 'Invalid rule' }, headers: {} },
+        message: 'Bad request',
+      };
+      mockAxiosInstance.request.mockRejectedValue(axiosError);
+      jest.spyOn(axios, 'isAxiosError').mockReturnValue(true);
+
+      await expect(
+        client.replaceConfiguredRules('sr-1', { bogus: { x: 'y' } }),
+      ).rejects.toThrow();
+    });
+  });
 });
diff --git a/tests/unit/style-rules-command.test.ts b/tests/unit/style-rules-command.test.ts
index 46473be..c294f0a 100644
--- a/tests/unit/style-rules-command.test.ts
+++ b/tests/unit/style-rules-command.test.ts
@@ -86,7 +86,10 @@ describe('StyleRulesCommand', () => {
           version: 2,
           creationTime: '2024-01-01T00:00:00Z',
           updatedTime: '2024-01-02T00:00:00Z',
-          configuredRules: ['rule1', 'rule2'],
+          configuredRules: {
+            punctuation: { quotation_mark: 'use_guillemets' },
+            spelling_and_grammar: { accents: 'preserve' },
+          },
           customInstructions: [
             { label: 'Formality', prompt: 'Keep it formal' },
             { label: 'Tone', prompt: 'Use friendly tone', sourceLanguage: 'en' },
@@ -96,7 +99,8 @@ describe('StyleRulesCommand', () => {
 
       const result = command.formatStyleRulesList(rules);
       expect(result).toContain('Detailed Style');
-      expect(result).toContain('rule1, rule2');
+      expect(result).toContain('punctuation:');
+      expect(result).toContain('quotation_mark: use_guillemets');
       expect(result).toContain('Formality: Keep it formal');
       expect(result).toContain('Tone: Use friendly tone [en]');
     });
@@ -110,7 +114,7 @@ describe('StyleRulesCommand', () => {
           version: 1,
           creationTime: '2024-01-01T00:00:00Z',
           updatedTime: '2024-01-02T00:00:00Z',
-          configuredRules: [],
+          configuredRules: {},
           customInstructions: [
             { label: 'Brevity', prompt: 'Keep sentences short' },
           ],
@@ -172,5 +176,324 @@ describe('StyleRulesCommand', () => {
       const result = command.formatStyleRulesJson([]);
       expect(JSON.parse(result)).toEqual([]);
     });
+
+    it('should sanitize ANSI escapes in rule name when formatting list text', () => {
+      const evil: StyleRule[] = [{
+        styleId: 'sr-1',
+        name: 'Evil\u001b[31mred',
+        language: 'en',
+        version: 1,
+        creationTime: 'c',
+        updatedTime: 'u',
+      }];
+      const result = command.formatStyleRulesList(evil);
+      expect(result).not.toContain('\u001b[31m');
+    });
+  });
+
+  describe('create', () => {
+    it('should proxy to service.createStyleRule', async () => {
+      await command.create({ name: 'X', language: 'en' });
+      expect(mockService.createStyleRule).toHaveBeenCalledWith({ name: 'X', language: 'en' });
+    });
+  });
+
+  describe('show', () => {
+    it('should proxy to service.getStyleRule with detailed=false by default', async () => {
+      await command.show('sr-1');
+      expect(mockService.getStyleRule).toHaveBeenCalledWith('sr-1', false);
+    });
+
+    it('should pass detailed=true when requested', async () => {
+      await command.show('sr-1', true);
+      expect(mockService.getStyleRule).toHaveBeenCalledWith('sr-1', true);
+    });
+  });
+
+  describe('update', () => {
+    it('should proxy to service.updateStyleRule', async () => {
+      await command.update('sr-1', { name: 'Renamed' });
+      expect(mockService.updateStyleRule).toHaveBeenCalledWith('sr-1', { name: 'Renamed' });
+    });
+  });
+
+  describe('delete', () => {
+    it('should proxy to service.deleteStyleRule', async () => {
+      await command.delete('sr-1');
+      expect(mockService.deleteStyleRule).toHaveBeenCalledWith('sr-1');
+    });
+  });
+
+  describe('replaceRules', () => {
+    it('should proxy to service.replaceConfiguredRules', async () => {
+      const rules = { punctuation: { quotation_mark: 'use_guillemets' } };
+      await command.replaceRules('sr-1', rules);
+      expect(mockService.replaceConfiguredRules).toHaveBeenCalledWith('sr-1', rules);
+    });
+  });
+
+  describe('formatStyleRule', () => {
+    const baseRule: StyleRule = {
+      styleId: 'sr-1',
+      name: 'My Style',
+      language: 'en',
+      version: 1,
+      creationTime: '2024-01-01T00:00:00Z',
+      updatedTime: '2024-01-02T00:00:00Z',
+    };
+
+    it('should render a basic rule in text', () => {
+      const result = command.formatStyleRule(baseRule);
+      expect(result).toContain('My Style');
+      expect(result).toContain('ID:       sr-1');
+      expect(result).toContain('Language: en');
+      expect(result).toContain('Version:  1');
+    });
+
+    it('should include configuredRules and customInstructions when detailed', () => {
+      const detailed: StyleRuleDetailed = {
+        ...baseRule,
+        configuredRules: {
+          punctuation: { quotation_mark: 'use_guillemets' },
+          spelling_and_grammar: { accents: 'preserve' },
+        },
+        customInstructions: [
+          { label: 'L', prompt: 'P' },
+          { label: 'M', prompt: 'Q', sourceLanguage: 'de' },
+        ],
+      };
+      const result = command.formatStyleRule(detailed);
+      expect(result).toContain('punctuation:');
+      expect(result).toContain('quotation_mark: use_guillemets');
+      expect(result).toContain('spelling_and_grammar:');
+      expect(result).toContain('- L: P');
+      expect(result).toContain('- M: Q [de]');
+    });
+
+    it('should sanitize ANSI escapes in rule name', () => {
+      const evil: StyleRule = { ...baseRule, name: 'Evil\u001b[31mred' };
+      const result = command.formatStyleRule(evil);
+      expect(result).not.toContain('\u001b[31m');
+    });
+
+    it('should sanitize ANSI escapes in custom instruction text', () => {
+      const evil: StyleRuleDetailed = {
+        ...baseRule,
+        configuredRules: {},
+        customInstructions: [{ label: 'L\u001b[31m', prompt: 'P\u001b[0m' }],
+      };
+      const result = command.formatStyleRule(evil);
+      expect(result).not.toContain('\u001b[31m');
+      expect(result).not.toContain('\u001b[0m');
+    });
+
+    it('should sanitize ANSI escapes in configured-rules keys and values', () => {
+      const evil: StyleRuleDetailed = {
+        ...baseRule,
+        configuredRules: { 'cat\u001b[31m': { 'key\u001b[32m': 'val\u001b[0m' } },
+        customInstructions: [],
+      };
+      const result = command.formatStyleRule(evil);
+      expect(result).not.toContain('\u001b');
+      expect(result).toContain('cat?[31m');
+      expect(result).toContain('key?[32m: val?[0m');
+    });
+  });
+
+  describe('listInstructions', () => {
+    it('should call service.getStyleRule with detailed=true and return the nested array', async () => {
+      mockService.getStyleRule.mockResolvedValue({
+        styleId: 'sr-1', name: 'X', language: 'en', version: 1,
+        creationTime: 'c', updatedTime: 'u',
+        configuredRules: {},
+        customInstructions: [
+          { label: 'tone', prompt: 'Be formal' },
+          { label: 'register', prompt: 'Use first person' },
+        ],
+      });
+
+      const result = await command.listInstructions('sr-1');
+      expect(mockService.getStyleRule).toHaveBeenCalledWith('sr-1', true);
+      expect(result).toHaveLength(2);
+      expect(result[0]?.label).toBe('tone');
+    });
+
+    it('should return empty array when rule has no customInstructions field', async () => {
+      mockService.getStyleRule.mockResolvedValue({
+        styleId: 'sr-1', name: 'X', language: 'en', version: 1,
+        creationTime: 'c', updatedTime: 'u',
+      });
+
+      const result = await command.listInstructions('sr-1');
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('addInstruction', () => {
+    it('should proxy to service.createCustomInstruction', async () => {
+      await command.addInstruction('sr-1', { label: 'L', prompt: 'P' });
+      expect(mockService.createCustomInstruction).toHaveBeenCalledWith('sr-1', { label: 'L', prompt: 'P' });
+    });
+  });
+
+  describe('updateInstruction', () => {
+    it('should proxy to service.updateCustomInstruction', async () => {
+      await command.updateInstruction('sr-1', 'tone', { prompt: 'New text' });
+      expect(mockService.updateCustomInstruction).toHaveBeenCalledWith('sr-1', 'tone', { prompt: 'New text' });
+    });
+  });
+
+  describe('removeInstruction', () => {
+    it('should proxy to service.deleteCustomInstruction', async () => {
+      await command.removeInstruction('sr-1', 'tone');
+      expect(mockService.deleteCustomInstruction).toHaveBeenCalledWith('sr-1', 'tone');
+    });
+  });
+
+  describe('formatCustomInstruction / formatCustomInstructionsList / formatCustomInstructionJson', () => {
+    it('should render a single instruction in text', () => {
+      const result = command.formatCustomInstruction({ label: 'tone', prompt: 'Be formal' });
+      expect(result).toContain('tone');
+      expect(result).toContain('Be formal');
+    });
+
+    it('should append source-language suffix when present', () => {
+      const result = command.formatCustomInstruction({
+        label: 'tone', prompt: 'Be formal', sourceLanguage: 'en',
+      });
+      expect(result).toContain('[en]');
+    });
+
+    it('should render empty list as a friendly message', () => {
+      expect(command.formatCustomInstructionsList([])).toBe('No custom instructions found.');
+    });
+
+    it('should render a list of instructions', () => {
+      const result = command.formatCustomInstructionsList([
+        { label: 'a', prompt: 'A' },
+        { label: 'b', prompt: 'B' },
+      ]);
+      expect(result).toContain('Found 2 custom instruction(s)');
+      expect(result).toContain('a');
+      expect(result).toContain('b');
+    });
+
+    it('should sanitize ANSI escapes in label and prompt', () => {
+      const result = command.formatCustomInstruction({
+        label: 'evil\u001b[31m',
+        prompt: 'also\u001b[0m',
+      });
+      expect(result.indexOf('\u001b')).toBe(-1);
+    });
+
+    it('should emit valid JSON preserving raw strings', () => {
+      const json = command.formatCustomInstructionJson([{ label: 'L', prompt: 'P' }]);
+      expect(JSON.parse(json)).toEqual([{ label: 'L', prompt: 'P' }]);
+    });
+  });
+
+  describe('formatStyleRuleJson', () => {
+    it('should emit valid JSON with raw name preserved', () => {
+      const rule: StyleRule = {
+        styleId: 'sr-1',
+        name: 'Raw\u001b[31mname',
+        language: 'en',
+        version: 1,
+        creationTime: 'c',
+        updatedTime: 'u',
+      };
+      const result = command.formatStyleRuleJson(rule);
+      const parsed = JSON.parse(result);
+      expect(parsed.styleId).toBe('sr-1');
+      // JSON path preserves the raw string; JSON.stringify escapes the control byte to \u001b
+      expect(parsed.name).toBe('Raw\u001b[31mname');
+      // but the emitted JSON source never contains the raw control byte
+      expect(result.indexOf('\u001b')).toBe(-1);
+    });
+  });
+
+  describe('formatStyleRulesTable', () => {
+    const baseRule: StyleRule = {
+      styleId: 'sr-1',
+      name: 'Corporate',
+      language: 'en',
+      version: 3,
+      creationTime: '2026-01-01T00:00:00Z',
+      updatedTime: '2026-04-01T00:00:00Z',
+    };
+
+    it('should return empty-state message when no rules', () => {
+      expect(command.formatStyleRulesTable([])).toBe('No style rules found.');
+    });
+
+    it('should include rule data in table body', () => {
+      const result = command.formatStyleRulesTable([baseRule]);
+      expect(result).toContain('Corporate');
+      expect(result).toContain('sr-1');
+      expect(result).toContain('en');
+      expect(result).toContain('3');
+      expect(result).toContain('2026-04-01');
+    });
+
+    it('should include Rules and Instructions count columns when any row is detailed', () => {
+      const detailed: StyleRuleDetailed = {
+        ...baseRule,
+        // 2 leaf settings across 1 category — Rules count = 2
+        configuredRules: { punctuation: { quotation_mark: 'use_guillemets', spacing: 'tight' } },
+        customInstructions: [{ label: 'tone', prompt: 'formal' }],
+      };
+      const result = command.formatStyleRulesTable([detailed]);
+      expect(result).toContain('Rules');
+      expect(result).toContain('Instructions');
+      // leaf count = 2 (Rules), instruction count = 1
+      expect(result).toMatch(/\b2\b/);
+      expect(result).toMatch(/\b1\b/);
+    });
+
+    it('should sanitize ANSI escapes in rule name', () => {
+      const evil: StyleRule = { ...baseRule, name: 'Evil\u001b[31mred' };
+      const result = command.formatStyleRulesTable([evil]);
+      // Raw user-authored ESC byte must not survive — sanitizer replaces it with '?'.
+      // (cli-table3 may emit its own ANSI for border color, which is fine: those escapes
+      // are under our control, not user input.)
+      expect(result).not.toContain('Evil\u001b');
+      expect(result).toContain('Evil?[31mred');
+    });
+  });
+
+  describe('formatCustomInstructionsTable', () => {
+    it('should return empty-state message when no instructions', () => {
+      expect(command.formatCustomInstructionsTable([])).toBe('No custom instructions found.');
+    });
+
+    it('should include label, prompt, and source columns', () => {
+      const result = command.formatCustomInstructionsTable([
+        { label: 'tone', prompt: 'Be formal', sourceLanguage: 'en' },
+      ]);
+      expect(result).toContain('Label');
+      expect(result).toContain('Prompt');
+      expect(result).toContain('Source');
+      expect(result).toContain('tone');
+      expect(result).toContain('Be formal');
+      expect(result).toContain('en');
+    });
+
+    it('should render em-dash placeholder when sourceLanguage absent', () => {
+      const result = command.formatCustomInstructionsTable([
+        { label: 'register', prompt: 'Use first person' },
+      ]);
+      expect(result).toContain('—');
+    });
+
+    it('should sanitize ANSI escapes in label and prompt', () => {
+      const result = command.formatCustomInstructionsTable([
+        { label: 'evil\u001b[31m', prompt: 'also\u001b[0m' },
+      ]);
+      // Raw user-authored ESC byte must not survive in either field.
+      expect(result).not.toContain('evil\u001b');
+      expect(result).not.toContain('also\u001b');
+      expect(result).toContain('evil?[31m');
+      expect(result).toContain('also?[0m');
+    });
   });
 });
diff --git a/tests/unit/style-rules-service.test.ts b/tests/unit/style-rules-service.test.ts
index 617b86d..dc26534 100644
--- a/tests/unit/style-rules-service.test.ts
+++ b/tests/unit/style-rules-service.test.ts
@@ -49,4 +49,75 @@ describe('StyleRulesService', () => {
 
     await expect(service.getStyleRules()).rejects.toThrow('Forbidden');
   });
+
+  it('should delegate createStyleRule to client', async () => {
+    const mockClient = createMockDeepLClient();
+    const service = new StyleRulesService(mockClient);
+    await service.createStyleRule({ name: 'X', language: 'en' });
+    expect(mockClient.createStyleRule).toHaveBeenCalledWith({ name: 'X', language: 'en' });
+  });
+
+  it('should delegate getStyleRule with detailed flag', async () => {
+    const mockClient = createMockDeepLClient();
+    const service = new StyleRulesService(mockClient);
+    await service.getStyleRule('sr-1', true);
+    expect(mockClient.getStyleRule).toHaveBeenCalledWith('sr-1', true);
+  });
+
+  it('should delegate getStyleRule with default detailed=false', async () => {
+    const mockClient = createMockDeepLClient();
+    const service = new StyleRulesService(mockClient);
+    await service.getStyleRule('sr-1');
+    expect(mockClient.getStyleRule).toHaveBeenCalledWith('sr-1', false);
+  });
+
+  it('should delegate updateStyleRule to client', async () => {
+    const mockClient = createMockDeepLClient();
+    const service = new StyleRulesService(mockClient);
+    await service.updateStyleRule('sr-1', { name: 'Renamed' });
+    expect(mockClient.updateStyleRule).toHaveBeenCalledWith('sr-1', { name: 'Renamed' });
+  });
+
+  it('should delegate deleteStyleRule to client', async () => {
+    const mockClient = createMockDeepLClient();
+    const service = new StyleRulesService(mockClient);
+    await service.deleteStyleRule('sr-1');
+    expect(mockClient.deleteStyleRule).toHaveBeenCalledWith('sr-1');
+  });
+
+  it('should delegate replaceConfiguredRules to client', async () => {
+    const mockClient = createMockDeepLClient();
+    const service = new StyleRulesService(mockClient);
+    const rules = { punctuation: { quotation_mark: 'use_guillemets' } };
+    await service.replaceConfiguredRules('sr-1', rules);
+    expect(mockClient.replaceConfiguredRules).toHaveBeenCalledWith('sr-1', rules);
+  });
+
+  it('should delegate createCustomInstruction to client', async () => {
+    const mockClient = createMockDeepLClient();
+    const service = new StyleRulesService(mockClient);
+    await service.createCustomInstruction('sr-1', { label: 'L', prompt: 'P' });
+    expect(mockClient.createCustomInstruction).toHaveBeenCalledWith('sr-1', { label: 'L', prompt: 'P' });
+  });
+
+  it('should delegate getCustomInstruction to client', async () => {
+    const mockClient = createMockDeepLClient();
+    const service = new StyleRulesService(mockClient);
+    await service.getCustomInstruction('sr-1', 'tone');
+    expect(mockClient.getCustomInstruction).toHaveBeenCalledWith('sr-1', 'tone');
+  });
+
+  it('should delegate updateCustomInstruction to client', async () => {
+    const mockClient = createMockDeepLClient();
+    const service = new StyleRulesService(mockClient);
+    await service.updateCustomInstruction('sr-1', 'tone', { prompt: 'New' });
+    expect(mockClient.updateCustomInstruction).toHaveBeenCalledWith('sr-1', 'tone', { prompt: 'New' });
+  });
+
+  it('should delegate deleteCustomInstruction to client', async () => {
+    const mockClient = createMockDeepLClient();
+    const service = new StyleRulesService(mockClient);
+    await service.deleteCustomInstruction('sr-1', 'tone');
+    expect(mockClient.deleteCustomInstruction).toHaveBeenCalledWith('sr-1', 'tone');
+  });
 });
diff --git a/tests/unit/sync/sync-utils.test.ts b/tests/unit/sync/sync-utils.test.ts
index 8794465..5772052 100644
--- a/tests/unit/sync/sync-utils.test.ts
+++ b/tests/unit/sync/sync-utils.test.ts
@@ -1,3 +1,6 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
 import {
   resolveTargetPath,
   assertPathWithinRoot,
@@ -136,6 +139,65 @@ describe('assertPathWithinRoot()', () => {
       expect(msg).toContain('?');
     }
   });
+
+  describe('symlink resolution', () => {
+    let realRoot: string;
+    let symlinkedRoot: string;
+
+    beforeAll(() => {
+      // Create a real directory and a symlink pointing at it. The macOS /tmp
+      // → /private/tmp case is the canonical example; this test reproduces
+      // that shape portably under os.tmpdir().
+      realRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'kxri-real-'));
+      symlinkedRoot = path.join(os.tmpdir(), `kxri-link-${process.pid}-${Date.now()}`);
+      fs.symlinkSync(realRoot, symlinkedRoot);
+    });
+
+    afterAll(() => {
+      try { fs.unlinkSync(symlinkedRoot); } catch { /* may not exist */ }
+      try { fs.rmSync(realRoot, { recursive: true, force: true }); } catch { /* best effort */ }
+    });
+
+    it('accepts a path under the realpath when projectRoot is the symlink', () => {
+      // projectRoot typed as the symlink, output path under the real form
+      // → must pass: both resolve through realpath to the same inode.
+      const outputViaReal = path.join(realRoot, 'out.xlf');
+      expect(() => assertPathWithinRoot(outputViaReal, symlinkedRoot)).not.toThrow();
+    });
+
+    it('accepts a path under the symlink when projectRoot is the realpath', () => {
+      // The reverse macOS case: loadSyncConfig captures the resolved root
+      // (/private/tmp/foo) but the user types --output via the symlink form
+      // (/tmp/foo/out.xlf). Both forms must resolve identically.
+      const outputViaSymlink = path.join(symlinkedRoot, 'out.xlf');
+      expect(() => assertPathWithinRoot(outputViaSymlink, realRoot)).not.toThrow();
+    });
+
+    it('rejects a symlink inside the project that points outside', () => {
+      // Defense-in-depth: symlink-based escapes are now caught by realpath
+      // resolution. A symlink inside the project pointing at a sibling
+      // path must be rejected.
+      const escapeTarget = fs.mkdtempSync(path.join(os.tmpdir(), 'kxri-escape-'));
+      const escapeLink = path.join(realRoot, 'escape');
+      fs.symlinkSync(escapeTarget, escapeLink);
+      try {
+        expect(() =>
+          assertPathWithinRoot(path.join(escapeLink, 'leak.xlf'), realRoot),
+        ).toThrow(ValidationError);
+      } finally {
+        fs.unlinkSync(escapeLink);
+        fs.rmSync(escapeTarget, { recursive: true, force: true });
+      }
+    });
+
+    it('accepts a non-existent path under an existing root (output-path case)', () => {
+      // Output paths typically do not exist when assertPathWithinRoot runs.
+      // The helper walks up to the closest existing ancestor and resolves
+      // through that, then re-appends the unresolved tail.
+      const futureOutput = path.join(realRoot, 'subdir', 'will-not-exist.xlf');
+      expect(() => assertPathWithinRoot(futureOutput, realRoot)).not.toThrow();
+    });
+  });
 });
 
 describe('resolveTargetPath() error message sanitization', () => {
diff --git a/tests/unit/usage-command.test.ts b/tests/unit/usage-command.test.ts
index d61687c..1237413 100644
--- a/tests/unit/usage-command.test.ts
+++ b/tests/unit/usage-command.test.ts
@@ -388,4 +388,65 @@ describe('UsageCommand', () => {
       expect(formatted).toContain('Product Breakdown:');
     });
   });
+
+  describe('formatUsageTable', () => {
+    it('should render Resource/Used/Limit/Usage columns with the Characters row', () => {
+      const result = usageCommand.formatUsageTable({
+        characterCount: 250000,
+        characterLimit: 500000,
+      });
+      expect(result).toContain('Resource');
+      expect(result).toContain('Used');
+      expect(result).toContain('Limit');
+      expect(result).toContain('Usage');
+      expect(result).toContain('Characters');
+      expect(result).toContain('250,000');
+      expect(result).toContain('500,000');
+      expect(result).toContain('50.0%');
+    });
+
+    it('should report unlimited when characterLimit is zero', () => {
+      const result = usageCommand.formatUsageTable({
+        characterCount: 100,
+        characterLimit: 0,
+      });
+      expect(result).toContain('unlimited');
+      expect(result).toContain('—'); // pct() returns em-dash when limit=0
+    });
+
+    it('should add API key, account-unit, and STT rows when those fields are present', () => {
+      const result = usageCommand.formatUsageTable({
+        characterCount: 100,
+        characterLimit: 500,
+        accountUnitCount: 5,
+        accountUnitLimit: 10,
+        apiKeyUnitCount: 2,
+        apiKeyUnitLimit: 4,
+        speechToTextMillisecondsCount: 60000,
+        speechToTextMillisecondsLimit: 600000,
+      });
+      expect(result).toContain('Account units');
+      expect(result).toContain('API key units');
+      expect(result).toContain('Speech-to-text');
+    });
+
+    it('should append a Product Breakdown table when products are present', () => {
+      const result = usageCommand.formatUsageTable({
+        characterCount: 1000,
+        characterLimit: 10000,
+        products: [
+          { productType: 'translate', characterCount: 900, apiKeyCharacterCount: 800 },
+          {
+            productType: 'speech_to_text',
+            characterCount: 120000,
+            apiKeyCharacterCount: 120000,
+            billingUnit: 'milliseconds',
+          },
+        ],
+      });
+      expect(result).toContain('Product Breakdown:');
+      expect(result).toContain('translate');
+      expect(result).toContain('speech_to_text');
+    });
+  });
 });
diff --git a/tests/unit/write-client.test.ts b/tests/unit/write-client.test.ts
index 01b3107..47759c5 100644
--- a/tests/unit/write-client.test.ts
+++ b/tests/unit/write-client.test.ts
@@ -205,5 +205,47 @@ describe('WriteClient', () => {
         client.improveText('Test', {})
       ).rejects.toThrow();
     });
+
+    it('should append docs hint on 400 when writingStyle was sent', async () => {
+      const axiosError = {
+        isAxiosError: true,
+        response: { status: 400, data: { message: "Style 'business' is not supported for 'ja'" }, headers: {} },
+        message: 'Bad request',
+      };
+      mockAxiosInstance.request.mockRejectedValue(axiosError);
+      jest.spyOn(axios, 'isAxiosError').mockReturnValue(true);
+
+      await expect(
+        client.improveText('Test', { targetLang: 'ja', writingStyle: 'business' })
+      ).rejects.toThrow(/See docs\/API\.md for supported target language \/ style \/ tone combinations/);
+    });
+
+    it('should append docs hint on 400 when tone was sent', async () => {
+      const axiosError = {
+        isAxiosError: true,
+        response: { status: 400, data: { message: "Tone 'friendly' is not supported for 'ko'" }, headers: {} },
+        message: 'Bad request',
+      };
+      mockAxiosInstance.request.mockRejectedValue(axiosError);
+      jest.spyOn(axios, 'isAxiosError').mockReturnValue(true);
+
+      await expect(
+        client.improveText('Test', { targetLang: 'ko', tone: 'friendly' })
+      ).rejects.toThrow(/See docs\/API\.md for supported target language \/ style \/ tone combinations/);
+    });
+
+    it('should NOT append docs hint on 400 when neither style nor tone was sent', async () => {
+      const axiosError = {
+        isAxiosError: true,
+        response: { status: 400, data: { message: 'Generic bad request' }, headers: {} },
+        message: 'Bad request',
+      };
+      mockAxiosInstance.request.mockRejectedValue(axiosError);
+      jest.spyOn(axios, 'isAxiosError').mockReturnValue(true);
+
+      await expect(
+        client.improveText('Test', { targetLang: 'ja' })
+      ).rejects.not.toThrow(/See docs\/API\.md/);
+    });
   });
 });