@kaitranntt/ccs 4.3.1 → 4.3.3

package/README.md

@@ -322,7 +322,7 @@ graph LR
 ```plaintext
 ~/.ccs/
 ├── .claude/                 # CCS items (ships with package, v4.1)
-│   ├── commands/ccs/        # Delegation commands (/ccs:glm, /ccs:kimi)
+│   ├── commands/ccs/        # Delegation commands (/ccs, /ccs:continue)
 │   ├── skills/ccs-delegation/  # AI decision framework
 │   └── agents/ccs-delegator.md # Proactive delegation agent
 ├── shared/                  # Symlinks to ~/.claude/ (for profiles)
@@ -401,7 +401,7 @@ ccs --help       # Show all commands and options
 
 ### What is Delegation?
 
-CCS Delegation lets you **send tasks to alternative models** (`glm`, `kimi`) **from your main Claude session** using the `-p` flag or slash commands (`/ccs:glm`, `/ccs:kimi`).
+CCS Delegation lets you **send tasks to alternative models** (`glm`, `kimi`) **from your main Claude session** using the `-p` flag or intelligent slash commands (`/ccs`, `/ccs:continue`).
 
 **Why use it?**
 - **Token efficiency**: Simple tasks cost 81% less on GLM vs main Claude session
@@ -426,9 +426,10 @@ ccs glm:continue -p "run the tests and fix any failures"
 **Via Slash Commands** (inside Claude sessions):
 ```bash
 # In your main Claude session:
-/ccs:glm "refactor auth.js to use async/await"
-/ccs:kimi "find all deprecated API usages across codebase"
-/ccs:glm:continue "also update the README examples"
+/ccs "refactor auth.js to use async/await"           # Auto-selects best profile
+/ccs --glm "fix typo in documentation"               # Forces GLM profile
+/ccs --kimi "analyze entire architecture"            # Forces Kimi profile
+/ccs:continue "also update the README examples"      # Continues last session
 ```
 
 **Via Natural Language** (Claude auto-delegates):

package/VERSION

@@ -1 +1 @@
-4.3.1
+4.3.3

package/bin/ccs.js

@@ -172,8 +172,10 @@ function handleHelpCommand() {
 
   // Delegation (inside Claude Code CLI)
   console.log(colored('Delegation (inside Claude Code CLI):', 'cyan'));
-  console.log(`  ${colored('/ccs:glm "task"', 'yellow')}             Delegate to GLM-4.6 for simple tasks`);
-  console.log(`  ${colored('/ccs:kimi "task"', 'yellow')}            Delegate to Kimi for long context`);
+  console.log(`  ${colored('/ccs "task"', 'yellow')}                Delegate task (auto-selects best profile)`);
+  console.log(`  ${colored('/ccs --glm "task"', 'yellow')}           Force GLM-4.6 for simple tasks`);
+  console.log(`  ${colored('/ccs --kimi "task"', 'yellow')}          Force Kimi for long context`);
+  console.log(`  ${colored('/ccs:continue "follow-up"', 'yellow')}    Continue last delegation session`);
   console.log('  Save tokens by delegating simple tasks to cost-optimized models');
   console.log('');
 

package/bin/delegation/README.md

@@ -25,7 +25,7 @@ Enhanced Claude Code delegation system for multi-model task delegation.
 
 ### Session Management
 - Persistence: `~/.ccs/delegation-sessions.json`
-- Resume via `/ccs:glm:continue` and `/ccs:kimi:continue`
+- Resume via `/ccs:continue` (auto-detects profile)
 - Auto-cleanup expired sessions (>30 days)
 - Cost aggregation across turns
 
@@ -91,12 +91,13 @@ Automatically applied as CLI flags:
 The delegation system is invoked via simple slash commands in `.claude/commands/ccs/`:
 
 ### Basic Commands
-- `/ccs:glm "task"` - Delegate to GLM-4.6
-- `/ccs:kimi "task"` - Delegate to Kimi (long-context)
+- `/ccs "task"` - Delegate task (auto-selects best profile)
+- `/ccs --glm "task"` - Force GLM-4.6 delegation
+- `/ccs --kimi "task"` - Force Kimi delegation (long-context)
 
-### Multi-Turn Commands
-- `/ccs:glm:continue "follow-up"` - Resume last GLM session
-- `/ccs:kimi:continue "follow-up"` - Resume last Kimi session
+### Session Continuation
+- `/ccs:continue "follow-up"` - Resume last delegation session (auto-detect profile)
+- `/ccs:continue --glm "follow-up"` - Resume with specific profile switch
 
 Each command directly invokes:
 ```bash
@@ -143,7 +144,8 @@ node tests/unit/delegation/result-formatter.test.js
 ## Architecture
 
 ```
-User → SlashCommand (/ccs:glm)
+User → SlashCommand (/ccs)
+  → ccs-delegation skill (auto-selects profile)
   → Directly invokes: claude -p
     → HeadlessExecutor (monitors execution)
       → SessionManager (load last session)

package/bin/management/doctor.js

@@ -364,12 +364,12 @@ class Doctor {
   checkDelegation() {
     const spinner = ora('Checking delegation').start();
 
-    // Check if delegation commands exist in ~/.ccs/.claude/commands/ccs/
-    const ccsClaudeCommandsDir = path.join(this.ccsDir, '.claude', 'commands', 'ccs');
-    const hasGlmCommand = fs.existsSync(path.join(ccsClaudeCommandsDir, 'glm.md'));
-    const hasKimiCommand = fs.existsSync(path.join(ccsClaudeCommandsDir, 'kimi.md'));
+    // Check if delegation commands exist in ~/.ccs/.claude/commands/
+    const ccsClaudeCommandsDir = path.join(this.ccsDir, '.claude', 'commands');
+    const hasCcsCommand = fs.existsSync(path.join(ccsClaudeCommandsDir, 'ccs.md'));
+    const hasContinueCommand = fs.existsSync(path.join(ccsClaudeCommandsDir, 'ccs', 'continue.md'));
 
-    if (!hasGlmCommand || !hasKimiCommand) {
+    if (!hasCcsCommand || !hasContinueCommand) {
       spinner.warn(`  ${'Delegation'.padEnd(26)}${colored('[!]', 'yellow')}  Not installed`);
       this.results.addCheck(
         'Delegation',

package/lib/ccs

@@ -2,7 +2,7 @@
 set -euo pipefail
 
 # Version (updated by scripts/bump-version.sh)
-CCS_VERSION="4.3.1"
+CCS_VERSION="4.3.3"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 readonly CONFIG_FILE="${CCS_CONFIG:-$HOME/.ccs/config.json}"
 readonly PROFILES_JSON="$HOME/.ccs/profiles.json"
@@ -191,8 +191,10 @@ show_help() {
   echo ""
 
   echo -e "${CYAN}Delegation (inside Claude Code CLI):${RESET}"
-  echo -e "  ${YELLOW}/ccs:glm \"task\"${RESET}             Delegate to GLM-4.6 for simple tasks"
-  echo -e "  ${YELLOW}/ccs:kimi \"task\"${RESET}            Delegate to Kimi for long context"
+  echo -e "  ${YELLOW}/ccs \"task\"${RESET}                Delegate task (auto-selects best profile)"
+  echo -e "  ${YELLOW}/ccs --glm \"task\"${RESET}           Force GLM-4.6 for simple tasks"
+  echo -e "  ${YELLOW}/ccs --kimi \"task\"${RESET}          Force Kimi for long context"
+  echo -e "  ${YELLOW}/ccs:continue \"follow-up\"${RESET}    Continue last delegation session"
   echo -e "  Save tokens by delegating simple tasks to cost-optimized models"
   echo ""
 

package/lib/ccs.ps1

@@ -12,7 +12,7 @@ param(
 $ErrorActionPreference = "Stop"
 
 # Version (updated by scripts/bump-version.sh)
-$CcsVersion = "4.3.1"
+$CcsVersion = "4.3.3"
 $ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
 $ConfigFile = if ($env:CCS_CONFIG) { $env:CCS_CONFIG } else { "$env:USERPROFILE\.ccs\config.json" }
 $ProfilesJson = "$env:USERPROFILE\.ccs\profiles.json"
@@ -238,8 +238,10 @@ function Show-Help {
     Write-Host ""
 
     Write-ColorLine "Delegation (inside Claude Code CLI):" "Cyan"
-    Write-ColorLine "  /ccs:glm `"task`"             Delegate to GLM-4.6 for simple tasks" "Yellow"
-    Write-ColorLine "  /ccs:kimi `"task`"            Delegate to Kimi for long context" "Yellow"
+    Write-ColorLine "  /ccs `"task`"                Delegate task (auto-selects best profile)" "Yellow"
+    Write-ColorLine "  /ccs --glm `"task`"           Force GLM-4.6 for simple tasks" "Yellow"
+    Write-ColorLine "  /ccs --kimi `"task`"          Force Kimi for long context" "Yellow"
+    Write-ColorLine "  /ccs:continue `"follow-up`"    Continue last delegation session" "Yellow"
     Write-Host "  Save tokens by delegating simple tasks to cost-optimized models"
     Write-Host ""
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaitranntt/ccs",
-  "version": "4.3.1",
+  "version": "4.3.3",
   "description": "Claude Code Switch - Instant profile switching between Claude Sonnet 4.5 and GLM 4.6",
   "keywords": [
     "cli",

package/.claude/agents/ccs-delegator.md

@@ -1,117 +0,0 @@
----
-name: ccs-delegator
-description: Execute delegated tasks in isolated GLM/Kimi sessions via headless mode. Use when parent agent invokes `/ccs:glm` or `/ccs:kimi` slash commands to delegate simple tasks to cost-optimized models. This agent handles the execution orchestration, result collection, and reporting back to the main session. Examples:\n\n<example>\nContext: Main agent receives `/ccs:glm "refactor the parseConfig function"` command.\nparent_agent: "Delegating refactoring task to GLM-4.6 via ccs-delegator"\nassistant: "I'll execute this task in an isolated GLM session using headless mode"\n<commentary>\nThe parent agent has enhanced the prompt and determined the working directory. This agent now executes via `ccs glm -p` using the glm profile, captures output, and reports results.\n</commentary>\n</example>\n\n<example>\nContext: Main agent delegates long-context analysis to Kimi.\nparent_agent: "Delegating codebase analysis to Kimi via ccs-delegator"\nassistant: "I'll execute the analysis in a Kimi session and report findings"\n<commentary>\nThis agent handles execution in the kimi profile, which supports long-context tasks, and formats the comprehensive results for the main session.\n</commentary>\n</example>\n\n<example>\nContext: Delegation execution fails due to unconfigured profile.\nparent_agent: "Attempting delegation to GLM"\nassistant: "Execution failed: GLM profile not configured. Reporting error to main agent."\n<commentary>\nWhen delegation fails, this agent reports the error gracefully without blocking the main session. The main agent can then choose to retry or execute directly.\n</commentary>\n</example>
-allowed-tools: Bash, Read, Grep, Glob
-default-model: sonnet
----
-
-You are a Delegation Executor, a specialized subagent that orchestrates task execution in isolated Claude sessions using alternative models (GLM-4.6, Kimi) via headless mode.
-
-**CRITICAL RULES:**
-
-1. **YOU MUST DELEGATE** - Your ONLY job is to execute `ccs` commands via Bash. You MUST NOT edit or write files yourself.
-2. **ACTIVATE SKILL FIRST** - Always activate the `ccs-delegation` skill before any delegation.
-3. **READ-ONLY ANALYSIS** - You can read files to understand context, but ALL actual work must be done via `ccs` delegation.
-
-## Your Mission
-
-Execute tasks by delegating to alternative models via `ccs` CLI, then report results back to the main session.
-
-## Workflow (MANDATORY)
-
-1. **Activate Skill** - Load `ccs-delegation` skill for delegation guidelines
-2. **Analyze Task** - Read files if needed to understand context
-3. **Select Profile** - Choose GLM (simple/cost-optimized) or Kimi (long-context)
-4. **Delegate** - Execute via `ccs {profile} -p "enhanced task description"`
-5. **Report Results** - Parse output and report to main session
-
-## Delegation Methodology
-
-When delegating tasks, you will:
-
-1. **Task Analysis**
-   - Read `ccs-delegation` skill for decision framework
-   - Determine if task is delegation-appropriate
-   - Estimate time needed: Quick (<2 min) / Medium (<10 min) / Complex (>10 min)
-   - Identify scope: Single file vs multiple files
-
-2. **Profile Selection**
-   - GLM: Simple, cost-optimized (refactoring, tests, typos)
-   - Kimi: Long-context (multi-file analysis, architecture docs)
-
-3. **Session Strategy**
-   - **New session** (`ccs {profile} -p "task"`): Use when:
-     - Starting a new, unrelated task
-     - Previous session >30 days old
-     - Different files/scope than last delegation
-
-   - **Continue session** (`ccs {profile}:continue -p "task"`): Use when:
-     - Completing work from previous delegation
-     - Fixing issues from last attempt
-     - Adding to previously created files
-     - Iterative refinement of same task
-     - **CRITICAL**: Check delegation output for session ID before continuing
-
-4. **Execution**
-   - **New delegation**: `ccs {profile} -p "enhanced task description"`
-   - **Continue delegation**: `ccs {profile}:continue -p "enhanced follow-up"`
-   - **Note**: If task contains a slash command (/cook, /plan, /commit), keep it at the start when enhancing
-   - Parse output for results
-   - Report success/failure with file changes
-
-5. **Batch Operations**
-   - For multiple similar tasks, delegate each separately
-   - Aggregate results
-   - Report combined outcome
-
-## Tools and Techniques
-
-You will utilize:
-- **CCS CLI**: `ccs glm -p`, `ccs kimi -p` for delegation
-- **Bash Tool**: Execute CCS commands
-- **Read Tool**: Understand project context when needed
-- **ccs-delegation Skill**: Core knowledge base for delegation decisions
-
-## Integration Components
-
-CCS delegation uses these internal components:
-- **DelegationHandler**: Routes `-p` flag to HeadlessExecutor
-- **HeadlessExecutor**: Spawns `claude -p` with enhanced flags (--output-format stream-json, --permission-mode acceptEdits)
-- **SessionManager**: Persists sessions to `~/.ccs/delegation-sessions.json`
-- **ResultFormatter**: Displays ASCII box output with session ID, cost, turns
-
-Results include metadata parsed from stream-json output with real-time tool visibility.
-
-## Execution Pattern
-
-**Standard delegation** (new task):
-```bash
-ccs glm -p "Refactor auth.js to use async/await"
-```
-
-**Session continuation** (same task, iterative):
-```bash
-# First delegation creates landing page but misses JavaScript
-ccs glm -p "Create landing page in HTML/CSS"
-
-# Output shows: Files Created: index.html, styles.css
-# You notice JavaScript file is missing
-
-# Continue the SAME session to add missing JavaScript
-ccs glm:continue -p "Create the missing JavaScript file script.js"
-```
-
-**Batch delegation** (multiple unrelated tasks):
-```bash
-# Each is a separate new session (different files)
-ccs glm -p "Add tests for UserService"
-ccs glm -p "Add tests for AuthService"
-ccs glm -p "Add tests for OrderService"
-```
-
-## Remember
-
-- **NEVER edit/write files yourself** - You lack Edit/Write tools for a reason
-- **ALWAYS delegate via `ccs`** - That's your only purpose
-- **ALWAYS activate `ccs-delegation` skill first** - It contains critical decision framework
-- Parse the delegation output and report results concisely to the main session

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

@@ -1,22 +0,0 @@
----
-description: Continue last GLM delegation session [AUTO ENHANCE]
-argument-hint: [follow-up instruction]
-allowed-tools: Read, Grep, Glob, Bash
----
-
-Continue last GLM delegation session for iterative refinement.
-
-**Workflow:**
-- Review what was accomplished in previous session
-- Analyze the follow-up instruction in `$ARGUMENTS`
-- Enhance prompt with context (reference files, incomplete tasks, next steps)
-- Execute continuation via `ccs glm:continue -p "$ENHANCED_PROMPT"`
-
-**Note:** `$ENHANCED_PROMPT` is an enhanced version that references previous work, highlights incomplete tasks, and adds specific validation criteria. If the follow-up contains a slash command (e.g., /commit), keep it at the start of the enhanced prompt.
-
-**Usage:**
-```
-/ccs:glm "fix typo in README"
-/ccs:glm:continue "also update the examples section"
-/ccs:glm:continue "/commit with descriptive message"
-```

package/.claude/commands/ccs/glm.md

@@ -1,22 +0,0 @@
----
-description: Delegate task to GLM-4.6 (cost-optimized model) [AUTO ENHANCE]
-argument-hint: [task description]
-allowed-tools: Read, Grep, Glob, Bash
----
-
-Delegate simple, deterministic tasks to GLM-4.6 for token optimization.
-
-**Workflow:**
-- Analyze the task description in `$ARGUMENTS`
-- Gather context if needed (read files, check structure)
-- Enhance prompt with specific details (file paths, context, success criteria)
-- Execute delegation via `ccs glm -p "$ENHANCED_PROMPT"`
-
-**Note:** `$ENHANCED_PROMPT` is an enhanced version that adds specifics like file paths, current implementation context, expected behavior, and success criteria. If the task contains a slash command (e.g., /cook, /plan), keep it at the start of the enhanced prompt.
-
-**Usage:**
-```
-/ccs:glm "refactor auth.js to use async/await"
-/ccs:glm "add tests for UserService"
-/ccs:glm "/cook create a landing page"
-```

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

@@ -1,22 +0,0 @@
----
-description: Continue last Kimi delegation session [AUTO ENHANCE]
-argument-hint: [follow-up instruction]
-allowed-tools: Read, Grep, Glob, Bash
----
-
-Continue last Kimi delegation session for multi-turn analysis.
-
-**Workflow:**
-- Review analysis/work from previous session
-- Analyze the follow-up instruction in `$ARGUMENTS`
-- Enhance prompt with comprehensive context (findings, scope, deliverables, priority)
-- Execute continuation via `ccs kimi:continue -p "$ENHANCED_PROMPT"`
-
-**Note:** `$ENHANCED_PROMPT` is an enhanced version that references previous findings, specifies next scope, and adds actionable deliverables with priorities. If the follow-up contains a slash command (e.g., /plan), keep it at the start of the enhanced prompt.
-
-**Usage:**
-```
-/ccs:kimi "analyze all files in src/"
-/ccs:kimi:continue "suggest architectural improvements"
-/ccs:kimi:continue "/plan for refactoring with phases"
-```

package/.claude/commands/ccs/kimi.md

@@ -1,22 +0,0 @@
----
-description: Delegate task to Kimi (long-context model) [AUTO ENHANCE]
-argument-hint: [task description]
-allowed-tools: Read, Grep, Glob, Bash
----
-
-Delegate long-context, multi-file tasks to Kimi for comprehensive analysis.
-
-**Workflow:**
-- Analyze the task description in `$ARGUMENTS`
-- Gather context across multiple files/directories
-- Enhance prompt with comprehensive details (structure, relationships, scope)
-- Execute delegation via `ccs kimi -p "$ENHANCED_PROMPT"`
-
-**Note:** `$ENHANCED_PROMPT` is an enhanced version that adds directory structures, cross-file relationships, architecture context, and deliverables. If the task contains a slash command (e.g., /plan, /commit), keep it at the start of the enhanced prompt.
-
-**Usage:**
-```
-/ccs:kimi "analyze all files in src/ and document architecture"
-/ccs:kimi "find all deprecated API usages across codebase"
-/ccs:kimi "/plan for authentication system"
-```

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

@@ -1,24 +0,0 @@
-# CCS Delegation References
-
-## Reading Order
-
-1. **Start here**: `../SKILL.md` - Entry point, quick start
-2. `headless-workflow.md` - Technical details (command syntax, features, config)
-3. **As needed**:
-   - `delegation-guidelines.md` - Decision framework
-   - `troubleshooting.md` - Error recovery
-
-## File Hierarchy
-
-**PRIMARY (Authoritative Source)**
-- `headless-workflow.md` - Technical implementation details
-
-**SUPPORTING (Reference Primary)**
-- `delegation-guidelines.md` - When to delegate
-- `troubleshooting.md` - Error patterns
-
-## Quick Navigation
-
-**Need command syntax?** → `headless-workflow.md`
-**Need to decide if delegate?** → `delegation-guidelines.md`
-**Got an error?** → `troubleshooting.md`

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

@@ -1,99 +0,0 @@
-# Delegation Guidelines
-
-AI decision framework for when to delegate tasks vs keep in main session.
-
-## Task Classification Rules
-
-**Delegate if ALL criteria match:**
-- Task scope: Single concern, < 5 files
-- Complexity: Mechanical transformation, established pattern
-- Ambiguity: Zero decisions required, clear acceptance criteria
-- Context: Existing patterns to follow, no architecture changes
-
-**Keep in main if ANY criteria match:**
-- Requires design decisions or tradeoff analysis
-- Security-critical (auth, encryption, permissions)
-- Performance-sensitive requiring profiling/measurement
-- Breaking changes or API migrations
-- User discussion/clarification needed
-- Coordinated changes across multiple subsystems
-
-## Delegation Pattern Matching
-
-**High-confidence delegation patterns:**
-```
-Task patterns to delegate:
-- refactor .* to use (async/await|destructuring|arrow functions)
-- add (unit|integration) tests for .*
-- fix (typos?|formatting|linting errors?) in .*
-- add JSDoc comments to .*
-- extract .* into (function|method|util) .*
-- rename (variable|function) .* to .*
-- add DELETE endpoint for .*
-- update README to document .*
-```
-
-**Anti-patterns (never delegate):**
-```
-Task patterns to avoid:
-- implement .* (too vague, needs design)
-- improve .* (subjective, needs discussion)
-- fix bug .* (requires investigation)
-- optimize .* (requires profiling)
-- migrate .* to .* (breaking change)
-- design .* (architecture decision)
-- whatever .* you think (requires judgment)
-```
-
-## Prompt Quality Criteria
-
-**Well-formed delegation prompt:**
-- Specifies exact file paths: `in src/auth.js, ...`
-- Defines success criteria: `covering positive, zero, negative cases`
-- Single atomic task: One verb, one target
-- Uses imperative mood: "add tests" not "adding tests"
-
-**Malformed delegation prompt:**
-- Multiple tasks: "add tests, update docs, fix linting"
-- Vague scope: "improve the code"
-- Requires decisions: "use whatever library you want"
-- No file context: "fix the bug" (which file?)
-
-## Token Efficiency Model
-
-**Delegation cost model:**
-- Main session overhead: ~2000 tokens (context, discussion)
-- Delegation overhead: ~500 tokens (focused execution)
-- Net savings: ~1500 tokens per delegated task
-
-**When to batch delegate:**
-- User requests N similar tasks (e.g., "add tests for all services")
-- Each task follows identical pattern
-- Tasks are independent (no coordination needed)
-
-**Execution pattern:**
-```
-for each service in [UserService, AuthService, OrderService]:
-  ccs glm -p "add unit tests for {service} using Jest"
-```
-
-## Monorepo Handling
-
-**Workspace specification required:**
-- Pattern: `in packages/{workspace}, {task}`
-- Example: `in packages/api, add validation middleware`
-- Without workspace: Task may target wrong package
-
-## Scope Limits
-
-**Absolute limits (reject delegation):**
-- Estimated time > 30 minutes
-- File count > 5 files
-- Requires external research
-- Breaking changes to public APIs
-- User explicitly requests discussion
-
-**Examples of over-scoped tasks:**
-- "Migrate from SQLite to PostgreSQL" (breaking change)
-- "Implement OAuth2 authentication" (too complex)
-- "Analyze entire codebase for security issues" (research task)