@kaitranntt/ccs 4.3.1 → 4.3.3

package/.claude/commands/ccs/continue.md

@@ -0,0 +1,15 @@
+---
+description: Continue last CCS delegation session [AUTO ENHANCE]
+argument-hint: [follow-up instruction]
+---
+
+Activate `ccs-delegation` skill. The skill contains all execution logic.
+
+Task: Detect last-used profile from `~/.ccs/delegation-sessions.json`, parse `$ARGUMENTS`, enhance with previous context, execute continuation via CCS CLI.
+
+**Examples:**
+```
+/ccs:continue "also update the examples section"  # Use last profile
+/ccs:continue --glm "add unit tests"              # Switch profiles
+/ccs:continue "/commit with message"              # Nested slash command
+```

package/.claude/commands/ccs.md

@@ -0,0 +1,17 @@
+---
+description: Delegate task with intelligent profile selection [AUTO ENHANCE]
+argument-hint: [task description]
+---
+
+Activate `ccs-delegation` skill. The skill contains all execution logic.
+
+Task: Parse `$ARGUMENTS`, select optimal profile from `~/.ccs/config.json`, enhance prompt, execute delegation via CCS CLI.
+
+**Examples:**
+```
+/ccs "refactor auth.js to use async/await"    # Simple task
+/ccs "analyze entire architecture"            # Long-context task
+/ccs "think about caching strategy"           # Reasoning task
+/ccs --glm "add tests for UserService"        # Force specific profile
+/ccs "/cook create landing page"              # Nested slash command
+```

package/.claude/skills/ccs-delegation/CLAUDE.md.template

@@ -0,0 +1,17 @@
+# CCS Auto-Delegation
+
+Activate `ccs-delegation` skill for automatic delegation of eligible tasks.
+
+**Commands:**
+- `/ccs "task"` - Auto-select best profile (glm/kimi/custom)
+- `/ccs:continue "follow-up"` - Continue last session
+- `/ccs --glm "task"` - Force specific profile
+
+**Auto-delegates:** typo fixes, test additions, refactoring, JSDoc, docs updates
+**Override:** Say "don't delegate" to bypass automation
+
+**Examples:**
+- "use ccs to fix typos in README" → Auto-selects glm
+- "use ccs to analyze architecture" → Auto-selects kimi
+- "use ccs --glm to add tests" → Forces glm
+- "use ccs:continue to commit" → Continues last session

package/.claude/skills/ccs-delegation/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: ccs-delegation
-description: Delegate simple tasks to alternative models (GLM, Kimi) via CCS CLI for token optimization
-version: 2.2.0
+description: Auto-activate CCS CLI delegation for deterministic tasks. Parses user input, auto-selects optimal profile (glm/kimi/custom) from ~/.ccs/config.json, enhances prompts with context, executes via `ccs {profile} -p "task"` or `ccs {profile}:continue`, and reports results. Trigger: "use ccs [task]" patterns, typo/test/refactor keywords. Excludes: complex architecture, security-critical code, performance optimization, breaking changes.
+version: 3.0.0
 ---
 
 # CCS Delegation
@@ -10,9 +10,94 @@ Delegate deterministic tasks to cost-optimized models via CCS CLI.
 
 ## Core Concept
 
-Execute tasks via alternative models using `ccs {profile} -p "task"` equivalent to `claude --settings ~/.ccs/{profile}.settings -p "task"`
+Execute tasks via alternative models using:
+- **Initial delegation**: `ccs {profile} -p "task"`
+- **Session continuation**: `ccs {profile}:continue -p "follow-up"`
 
-**Profiles:** GLM (cost-optimized), Kimi (long-context)
+**Profile Selection:**
+- Auto-select from `~/.ccs/config.json` via task analysis
+- Profiles: glm (cost-optimized), kimi (long-context/reasoning), custom profiles
+- Override: `--{profile}` flag forces specific profile
+
+## User Invocation Patterns
+
+Users trigger delegation naturally:
+- "use ccs [task]" - Auto-select best profile
+- "use ccs --glm [task]" - Force GLM profile
+- "use ccs --kimi [task]" - Force Kimi profile
+- "use ccs:continue [task]" - Continue last session
+
+**Examples:**
+- "use ccs to fix typos in README.md"
+- "use ccs to analyze the entire architecture"
+- "use ccs --glm to add unit tests"
+- "use ccs:continue to commit the changes"
+
+## Agent Response Protocol
+
+**For `/ccs [task]`:**
+
+1. **Parse override flag**
+   - Scan task for pattern: `--(\w+)`
+   - If match: `profile = match[1]`, remove flag from task, skip to step 5
+   - If no match: continue to step 2
+
+2. **Discover profiles**
+   - Read `~/.ccs/config.json` using Read tool
+   - Extract `Object.keys(config.profiles)` → `availableProfiles[]`
+   - If file missing → Error: "CCS not configured. Run: ccs doctor"
+   - If empty → Error: "No profiles in config.json"
+
+3. **Analyze task requirements**
+   - Scan task for keywords:
+     - `/(think|analyze|reason|debug|investigate|evaluate)/i` → `needsReasoning = true`
+     - `/(architecture|entire|all files|codebase|analyze all)/i` → `needsLongContext = true`
+     - `/(typo|test|refactor|update|fix)/i` → `preferCostOptimized = true`
+
+4. **Select profile**
+   - For each profile in `availableProfiles`: classify by name pattern (see Profile Characteristic Inference table)
+   - If `needsReasoning`: filter profiles where `reasoning=true` → prefer kimi
+   - Else if `needsLongContext`: filter profiles where `context=long` → prefer kimi
+   - Else: filter profiles where `cost=low` → prefer glm
+   - `selectedProfile = filteredProfiles[0]`
+   - If `filteredProfiles.length === 0`: fallback to `glm` if exists, else first available
+   - If no profiles: Error
+
+5. **Enhance prompt**
+   - If task mentions files: gather context using Read tool
+   - Add: file paths, current implementation, expected behavior, success criteria
+   - Preserve slash commands at task start (e.g., `/cook`, `/commit`)
+
+6. **Execute delegation**
+   - Run: `ccs {selectedProfile} -p "$enhancedPrompt"` via Bash tool
+
+7. **Report results**
+   - Log: "Selected {profile} (reason: {reasoning/long-context/cost-optimized})"
+   - Report: Cost (USD), Duration (sec), Session ID, Exit code
+
+**For `/ccs:continue [follow-up]`:**
+
+1. **Detect profile**
+   - Read `~/.ccs/delegation-sessions.json` using Read tool
+   - Find most recent session (latest timestamp)
+   - Extract profile name from session data
+   - If no sessions → Error: "No previous delegation. Use /ccs first"
+
+2. **Parse override flag**
+   - Scan follow-up for pattern: `--(\w+)`
+   - If match: `profile = match[1]`, remove flag from follow-up, log profile switch
+   - If no match: use detected profile from step 1
+
+3. **Enhance prompt**
+   - Review previous work (check what was accomplished)
+   - Add: previous context, incomplete tasks, validation criteria
+   - Preserve slash commands at start
+
+4. **Execute continuation**
+   - Run: `ccs {profile}:continue -p "$enhancedPrompt"` via Bash tool
+
+5. **Report results**
+   - Report: Profile, Session #, Incremental cost, Total cost, Duration, Exit code
 
 ## Decision Framework
 
@@ -28,27 +113,77 @@ Execute tasks via alternative models using `ccs {profile} -p "task"` equivalent
 - Performance optimization
 - Breaking changes/migrations
 
-## Profile Selection
+## Profile Selection Logic
 
-- **GLM**: Simple tasks (<5 files, clear scope, cost-optimized)
-- **Kimi**: Long-context (multi-file analysis, architecture docs)
+**Task Analysis Keywords** (scan task string with regex):
 
-## Execution
+| Pattern | Variable | Example |
+|---------|----------|---------|
+| `/(think\|analyze\|reason\|debug\|investigate\|evaluate)/i` | `needsReasoning = true` | "think about caching" |
+| `/(architecture\|entire\|all files\|codebase\|analyze all)/i` | `needsLongContext = true` | "analyze all files" |
+| `/(typo\|test\|refactor\|update\|fix)/i` | `preferCostOptimized = true` | "fix typo in README" |
+
+**Profile Characteristic Inference** (classify by name pattern):
+
+| Profile Pattern | Cost | Context | Reasoning |
+|----------------|------|---------|-----------|
+| `/^glm/i` | low | standard | false |
+| `/^kimi/i` | medium | long | true |
+| `/^claude/i` | high | standard | false |
+| others | low | standard | false |
+
+**Selection Algorithm** (apply filters sequentially):
 
-User invocation via slash commands:
-```
-/ccs:glm "task"
-/ccs:glm:continue "follow-up"
 ```
+profiles = Object.keys(config.profiles)
+classified = profiles.map(p => ({name: p, ...inferCharacteristics(p)}))
+
+if (needsReasoning):
+  filtered = classified.filter(p => p.reasoning === true).sort(['kimi'])
+else if (needsLongContext):
+  filtered = classified.filter(p => p.context === 'long').sort(['kimi'])
+else:
+  filtered = classified.filter(p => p.cost === 'low').sort(['glm', ...])
+
+selected = filtered[0] || profiles.find(p => p === 'glm') || profiles[0]
+if (!selected): throw Error("No profiles configured")
 
-Agent execution via Bash tool:
-```bash
-ccs glm -p "task"
-ccs glm:continue -p "follow-up"
+log("Selected {selected} (reason: {reasoning|long-context|cost-optimized})")
 ```
 
+**Override Logic**:
+- Parse task for `/--(\w+)/`. If match: `profile = match[1]`, remove from task, skip selection
+
+## Example Delegation Tasks
+
+**Good candidates:**
+- "/ccs add unit tests for UserService using Jest"
+  → Auto-selects: glm (simple task)
+- "/ccs analyze entire architecture in src/"
+  → Auto-selects: kimi (long-context)
+- "/ccs think about the best database schema design"
+  → Auto-selects: kimi (reasoning)
+- "/ccs --glm refactor parseConfig to use destructuring"
+  → Forces: glm (override)
+
+**Bad candidates (keep in main):**
+- "implement OAuth" (too complex, needs design)
+- "improve performance" (requires profiling)
+- "fix the bug" (needs investigation)
+
+## Execution
+
+**Commands:**
+- `/ccs "task"` - Intelligent delegation (auto-select profile)
+- `/ccs --{profile} "task"` - Force specific profile
+- `/ccs:continue "follow-up"` - Continue last session (auto-detect profile)
+- `/ccs:continue --{profile} "follow-up"` - Continue with profile switch
+
+**Agent via Bash:**
+- Auto: `ccs {auto-selected} -p "task"`
+- Continue: `ccs {detected}:continue -p "follow-up"`
+
 ## References
 
-Technical details: `references/headless-workflow.md`
-Decision guide: `references/delegation-guidelines.md`
+Template: `CLAUDE.md.template` - Copy to user's CLAUDE.md for auto-delegation config
 Troubleshooting: `references/troubleshooting.md`

package/.claude/skills/ccs-delegation/references/troubleshooting.md

@@ -2,267 +2,200 @@
 
 AI-oriented error resolution guide for CCS delegation issues.
 
-## Error Pattern Matching
+**Structure**: Quick Reference → Error Catalog → Common Resolutions → Diagnostics → Recovery
 
-### Profile Configuration Errors
+**Cross-references**:
+- Technical details: `headless-workflow.md`
+- Decision framework: `delegation-guidelines.md`
 
-**Pattern:** `Profile 'X' is not configured for delegation`
-```
-Root cause: Missing ~/.ccs/{profile}.settings.json
-Resolution:
-  1. Check file exists: ls ~/.ccs/{profile}.settings.json
-  2. Run diagnostics: ccs doctor
-  3. If missing, user must configure profile manually
-```
+## Quick Reference
 
-**Pattern:** `Invalid API key` (401 error)
-```
-Root cause: API token expired or invalid
-Resolution:
-  1. Verify token exists in settings.json
-  2. Test with simple command: ccs {profile} "test"
-  3. If fails, user must regenerate token from provider
-```
+**Profile/Config Issues:**
+- E-001: "Profile 'X' not configured" → `ccs doctor`
+- E-002: "Invalid API key" (401) → Check `~/.ccs/{profile}.settings.json`
+- E-003: "Settings file not found" → `ccs doctor` to configure
+- E-004: JSON parse error (settings) → Validate with `jq . ~/.ccs/{profile}.settings.json`
 
-**Pattern:** `Settings file not found`
-```
-Root cause: ~/.ccs/{profile}.settings.json doesn't exist
-Resolution:
-  1. Run: ccs doctor
-  2. Shows missing profiles
-  3. User must configure manually
-```
+**Delegation Issues:**
+- D-001: "No previous session" → Run `ccs {profile} -p "task"` first
+- D-002: "Missing prompt" → Syntax: `ccs {profile} -p "prompt"`
+- D-003: "No profile specified" → Syntax: `ccs <profile> -p "task"`
+- D-005: File not found → Verify CWD (delegation runs in current directory)
 
-### Delegation Execution Errors
+**Session Issues:**
+- S-001: Session corrupted → `rm ~/.ccs/delegation-sessions.json`
+- S-002: Session expired → Start new: `ccs {profile} -p "task"`
 
-**Pattern:** `No previous session found for {profile}`
-```
-Root cause: Using :continue without initial session
-Resolution:
-  - Cannot use ccs {profile}:continue without prior session
-  - Must run: ccs {profile} -p "initial task" first
-  - Then can continue with: ccs {profile}:continue -p "follow-up"
-Example:
-  [X] ccs glm:continue -p "task"  # ERROR: no session
-  [OK] ccs glm -p "task"          # Creates session
-  [OK] ccs glm:continue -p "more" # Uses session
-```
+**Network Issues:**
+- N-001: Connection timeout → Check internet/endpoint → Retry
+- N-002: Rate limit (429) → Wait 60s → Retry
 
-**Pattern:** `Missing prompt after -p flag`
-```
-Root cause: No argument provided after -p
-Resolution:
-  - Syntax: ccs {profile} -p "prompt text"
-  - Quote prompt if contains spaces
-Example:
-  [X] ccs glm -p                    # ERROR
-  [OK] ccs glm -p "add tests"       # Correct
-```
+**CLI Issues:**
+- C-001: Claude CLI not found → Install from code.claude.com
+- C-002: Outdated version → Update: `ccs sync` or `ccs update`
 
-**Pattern:** `No profile specified`
-```
-Root cause: Command missing profile name
-Resolution:
-  - Syntax: ccs <profile> -p "task"
-  - Available profiles: glm, kimi
-Example:
-  [X] ccs -p "task"           # ERROR: no profile
-  [OK] ccs glm -p "task"      # Correct
-```
+**See Error Catalog below for detailed troubleshooting.**
 
-**Pattern:** Exit code 1 with JSON parse error
-```
-Root cause: Claude CLI returned non-stream-JSON output
-Resolution:
-  1. Check if --output-format stream-json is supported
-  2. Verify Claude CLI version (need recent version with stream-json support)
-  3. Test manually: claude -p "test" --output-format stream-json
-  4. If not supported, delegation won't work
-```
+## Error Catalog
 
-### Session Management Errors
+### Environment/Config Errors
 
-**Pattern:** Session file corrupted
-```
-Root cause: ~/.ccs/delegation-sessions.json malformed
-Resolution:
-  1. Backup file: cp ~/.ccs/delegation-sessions.json ~/.ccs/delegation-sessions.json.bak
-  2. Delete corrupted file: rm ~/.ccs/delegation-sessions.json
-  3. New file created on next delegation
-  4. Previous sessions lost but fresh start
-```
+| Code | Pattern | Root Cause | Resolution |
+|------|---------|------------|------------|
+| E-001 | Profile 'X' not configured | Missing settings file | `ccs doctor` → configure manually |
+| E-002 | Invalid API key (401) | Token expired/invalid | Verify token in settings.json → regenerate if needed |
+| E-003 | Settings file not found | File doesn't exist | `ccs doctor` → shows missing profiles |
+| E-004 | JSON parse error (settings) | Malformed JSON | Validate: `jq . ~/.ccs/{profile}.settings.json` |
 
-**Pattern:** Session expired
-```
-Root cause: Session older than 30 days
-Resolution:
-  - Sessions auto-expire after 30 days
-  - Start new session: ccs {profile} -p "task"
-  - Cannot resume expired sessions
+**Examples:**
+```bash
+[X] ccs glm -p "task"  # E-001: Profile not configured
+[OK] ccs doctor        # Shows: glm.settings.json missing
 ```
 
-### Network & API Errors
+### Delegation Execution Errors
 
-**Pattern:** Connection timeout
-```
-Root cause: Network issue or API endpoint unreachable
-Resolution:
-  1. Check internet: ping 8.8.8.8
-  2. Verify API endpoint in settings.json
-  3. Check firewall/proxy settings
-  4. Retry delegation
-```
+| Code | Pattern | Root Cause | Resolution |
+|------|---------|------------|------------|
+| D-001 | No previous session | Using :continue without init | Run `ccs {profile} -p "init"` first |
+| D-002 | Missing prompt after -p | No argument provided | Quote prompt: `ccs {profile} -p "text"` |
+| D-003 | No profile specified | Missing profile name | Syntax: `ccs <profile> -p "task"` |
+| D-004 | Invalid profile name | Profile doesn't exist | Check: `ccs doctor` for available profiles |
+| D-005 | File not found | CWD mismatch | Verify: delegation runs in current directory |
 
-**Pattern:** Rate limiting (429)
-```
-Root cause: Too many API requests
-Resolution:
-  1. Wait 60 seconds before retry
-  2. Reduce concurrent delegations
-  3. Check API quota limits
+**Examples:**
+```bash
+[X] ccs glm:continue -p "task"     # D-001: No session
+[OK] ccs glm -p "task"             # Creates session
+[OK] ccs glm:continue -p "more"    # Uses session
 ```
 
-### File Operation Errors
+### Session Management Errors
 
-**Pattern:** File not found during delegation
-```
-Root cause: Path doesn't exist or wrong working directory
-Resolution:
-  1. Delegation runs in cwd where command executed
-  2. Verify file exists: ls <file>
-  3. Use absolute paths in prompt if needed
-Example:
-  Prompt: "refactor src/auth.js"
-  Check: ls src/auth.js  # Must exist in cwd
-```
+| Code | Pattern | Root Cause | Resolution |
+|------|---------|------------|------------|
+| S-001 | Session file corrupted | Malformed JSON | `rm ~/.ccs/delegation-sessions.json` → fresh start |
+| S-002 | Session expired | >30 days old | Start new: `ccs {profile} -p "task"` |
+| S-003 | Session ID mismatch | ID not found | Check: `jq '.{profile}' ~/.ccs/delegation-sessions.json` |
+| S-004 | Cost aggregation error | Calculation failure | Reset session or ignore (doesn't affect execution) |
 
-**Pattern:** Permission denied writing files
-```
-Root cause: Insufficient permissions in target directory
-Resolution:
-  1. Check directory permissions: ls -la
-  2. Verify cwd is writable
-  3. Don't delegate in read-only directories
-```
+### Network/API Errors
 
-## Diagnostic Commands
+| Code | Pattern | Root Cause | Resolution |
+|------|---------|------------|------------|
+| N-001 | Connection timeout | Network/API unreachable | Check: internet, endpoint, firewall → Retry |
+| N-002 | Rate limiting (429) | Too many requests | Wait 60s → Retry |
+| N-003 | API endpoint unreachable | Wrong URL in settings | Verify ANTHROPIC_BASE_URL in settings.json |
+| N-004 | SSL/TLS error | Certificate issue | Check system certs, firewall SSL inspection |
 
-**Profile validation:**
-```bash
-ccs doctor                              # Check all profiles
-cat ~/.ccs/glm.settings.json            # Verify settings
-ccs glm "echo test" 2>&1                # Test execution
-```
+### File Operation Errors
 
-**Session inspection:**
-```bash
-cat ~/.ccs/delegation-sessions.json     # View sessions
-jq '.glm' ~/.ccs/delegation-sessions.json  # Check specific profile
-```
+| Code | Pattern | Root Cause | Resolution |
+|------|---------|------------|------------|
+| F-001 | File not found during delegation | Path doesn't exist in CWD | Verify: `ls <file>` from current directory |
+| F-002 | Permission denied (write) | Insufficient permissions | Check: `ls -la` directory permissions |
+| F-003 | Relative path failure | Path resolution issue | Use absolute paths in prompts if needed |
+| F-004 | Workspace confusion (monorepo) | Wrong package targeted | Specify workspace: "in packages/{name}, {task}" |
 
-**Delegation test:**
+**Example:**
 ```bash
-ccs glm -p "create test.txt file with 'hello'"  # Simple test
-cat test.txt                            # Verify result
+# Delegation runs in CWD where command executed
+ccs glm -p "refactor src/auth.js"
+# Verify: ls src/auth.js  # Must exist in current directory
 ```
 
-**Debug mode:**
+### Claude CLI Compatibility Errors
+
+| Code | Pattern | Root Cause | Resolution |
+|------|---------|------------|------------|
+| C-001 | Claude CLI not found | Not installed | Install from code.claude.com |
+| C-002 | Outdated CLI version | Old version | Update: `ccs sync` or `ccs update` |
+| C-003 | stream-json not supported | Version < required | Upgrade CLI: check `claude --version` |
+| C-004 | Permission mode unsupported | Old CLI version | Upgrade to support --permission-mode |
+
+**Check version:**
 ```bash
-export CCS_DEBUG=1
-ccs glm -p "task" 2>&1 | tee debug.log  # Capture full output
+claude --version  # Need recent version with --output-format stream-json
 ```
 
-## Decision Tree
+### Timeout/Resource Errors
 
-```
-Delegation fails?
-  │
-  ├─→ "Profile not configured"
-  │     └─→ Run: ccs doctor
-  │           └─→ Configure missing profile
-  │
-  ├─→ "No previous session"
-  │     └─→ Using :continue?
-  │           ├─→ YES: Run initial task first
-  │           └─→ NO: Different error
-  │
-  ├─→ "Missing prompt"
-  │     └─→ Check syntax: ccs {profile} -p "prompt"
-  │
-  ├─→ Exit code 1
-  │     └─→ Check error message
-  │           ├─→ JSON parse: Claude CLI version issue
-  │           ├─→ File not found: Verify paths
-  │           └─→ API error: Check network/token
-  │
-  └─→ Silent failure
-        └─→ Enable debug: export CCS_DEBUG=1
-```
+| Code | Pattern | Root Cause | Resolution |
+|------|---------|------------|------------|
+| T-001 | Execution timeout (10 min) | Task too complex/slow | Simplify task or split into smaller tasks |
+| T-002 | Memory limit exceeded | Large file processing | Reduce scope, process in batches |
+| T-003 | Process killed (SIGTERM) | External termination | Check system resources, retry |
 
-## Common Patterns to Avoid
+### Output Format Errors
 
-**Anti-pattern:** Delegating without profile validation
-```
-[X] Assume profile exists
-[OK] Run ccs doctor first to verify
-```
+| Code | Pattern | Root Cause | Resolution |
+|------|---------|------------|------------|
+| O-001 | JSON parse error (exit 1) | Non-stream-JSON output | Verify: `claude -p "test" --output-format stream-json` |
+| O-002 | Malformed JSONL | Corrupted stream | Enable debug: `export CCS_DEBUG=1` → check logs |
+| O-003 | Missing session_id | Incomplete response | Check CLI version, retry delegation |
+| O-004 | Type mismatch in response | Unexpected data type | Enable debug mode, report issue |
 
-**Anti-pattern:** Using :continue immediately
-```
-[X] ccs glm:continue -p "task"  # No initial session
-[OK] ccs glm -p "task" && ccs glm:continue -p "more"
-```
+## Common Resolution Patterns
 
-**Anti-pattern:** Delegating complex tasks
-```
-[X] ccs glm -p "implement OAuth2"  # Too complex
-[OK] ccs glm -p "add tests for login function"
+**Profile Validation:**
+```bash
+ccs doctor                          # Check all profiles
+cat ~/.ccs/{profile}.settings.json  # Verify settings
+ccs {profile} "test" 2>&1           # Test execution
 ```
 
-**Anti-pattern:** Vague prompts
+**Session Management:**
+```bash
+jq . ~/.ccs/delegation-sessions.json              # View all sessions
+jq '.{profile}' ~/.ccs/delegation-sessions.json   # Check specific profile
+rm ~/.ccs/delegation-sessions.json                # Reset (loses all sessions)
 ```
-[X] ccs glm -p "fix the bug"  # No context
-[OK] ccs glm -p "fix typo in src/auth.js line 42"
+
+**Debug Mode:**
+```bash
+export CCS_DEBUG=1
+ccs {profile} -p "task" 2>&1 | tee debug.log  # Capture full output
 ```
 
-## Recovery Procedures
+## Diagnostic Toolkit
 
-**Reset session state:**
-```bash
-rm ~/.ccs/delegation-sessions.json
-# Fresh start, all sessions lost
+**Profile diagnostics:**
+````bash
+ccs doctor        # All profiles status
+ccs --version     # CCS version + delegation status
+claude --version  # CLI version (check stream-json support)
 ```
 
-**Reconfigure profile:**
+**Session inspection:**
 ```bash
-ccs doctor  # Shows issues
-# Edit ~/.ccs/{profile}.settings.json manually
-# Verify: ccs {profile} "test"
+jq . ~/.ccs/delegation-sessions.json                    # All sessions
+jq '.glm.sessionId' ~/.ccs/delegation-sessions.json     # GLM session ID
+jq '.glm.totalCost' ~/.ccs/delegation-sessions.json     # Total cost
 ```
 
 **Test delegation flow:**
 ```bash
 # 1. Simple task
-ccs glm -p "create test.txt with content 'hello'"
+ccs glm -p "create test.txt with 'hello'"
 
-# 2. Verify session created
-cat ~/.ccs/delegation-sessions.json | jq '.glm.sessionId'
+# 2. Verify session
+jq '.glm.sessionId' ~/.ccs/delegation-sessions.json
 
-# 3. Test continue
+# 3. Continue
 ccs glm:continue -p "append 'world' to test.txt"
 
-# 4. Verify aggregation
-cat ~/.ccs/delegation-sessions.json | jq '.glm.turns'
+# 4. Check aggregation
+jq '.glm.turns' ~/.ccs/delegation-sessions.json
 ```
 
-## Emergency Fallback
+## Emergency Recovery
 
-If delegation completely broken:
+**Reset session state:**
 ```bash
-# Use Claude CLI directly
-claude -p "task" --settings ~/.ccs/glm.settings.json
+rm ~/.ccs/delegation-sessions.json  # Fresh start (loses all sessions)
+```
 
-# Bypass delegation (no -p flag)
-ccs glm
-# Then work interactively
+**Interactive mode (no -p flag):**
+```bash
+ccs {profile}  # Opens interactive session
 ```