oh-my-customcode 0.66.0 → 0.67.0

package/README.md

@@ -13,7 +13,7 @@
 
 **[한국어 문서 (Korean)](./README_ko.md)**
 
-46 agents. 99 skills. 21 rules. One command.
+46 agents. 100 skills. 21 rules. One command.
 
 ```bash
 npm install -g oh-my-customcode && cd your-project && omcustom init
@@ -146,7 +146,7 @@ Each agent declares its tools, model, memory scope, and limitations in YAML fron
 
 ---
 
-### Skills (99)
+### Skills (100)
 
 | Category | Count | Includes |
 |----------|-------|----------|
@@ -282,7 +282,7 @@ your-project/
 ├── CLAUDE.md                   # Entry point
 ├── .claude/
 │   ├── agents/                 # 46 agent definitions
-│   ├── skills/                 # 99 skill modules
+│   ├── skills/                 # 100 skill modules
 │   ├── rules/                  # 21 governance rules (R000-R021)
 │   ├── hooks/                  # 15 lifecycle hook scripts
 │   ├── schemas/                # Tool input validation schemas

package/dist/cli/index.js

@@ -9325,7 +9325,7 @@ var init_package = __esm(() => {
     workspaces: [
       "packages/*"
     ],
-    version: "0.66.0",
+    version: "0.67.0",
     description: "Batteries-included agent harness for Claude Code",
     type: "module",
     bin: {

package/dist/index.js

@@ -1674,7 +1674,7 @@ var package_default = {
   workspaces: [
     "packages/*"
   ],
-  version: "0.66.0",
+  version: "0.67.0",
   description: "Batteries-included agent harness for Claude Code",
   type: "module",
   bin: {

package/package.json

@@ -3,7 +3,7 @@
   "workspaces": [
     "packages/*"
   ],
-  "version": "0.66.0",
+  "version": "0.67.0",
   "description": "Batteries-included agent harness for Claude Code",
   "type": "module",
   "bin": {

package/templates/.claude/hooks/scripts/session-env-check.sh

@@ -31,6 +31,12 @@ if command -v gemini >/dev/null 2>&1; then
   fi
 fi
 
+# Check RTK CLI availability
+RTK_STATUS="unavailable"
+if command -v rtk >/dev/null 2>&1; then
+  RTK_STATUS="available"
+fi
+
 # Check Agent Teams availability
 AGENT_TEAMS_STATUS="disabled"
 if [ "${CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS:-0}" = "1" ]; then
@@ -145,6 +151,7 @@ STATUS_FILE="/tmp/.claude-env-status-${PPID}"
 cat > "$STATUS_FILE" << ENVEOF
 codex=${CODEX_STATUS}
 gemini=${GEMINI_STATUS}
+rtk=${RTK_STATUS}
 agent_teams=${AGENT_TEAMS_STATUS}
 git_branch=${CURRENT_BRANCH}
 claude_version=${CLAUDE_VERSION}
@@ -156,6 +163,7 @@ ENVEOF
 # Report to stderr (visible in conversation)
 echo "  codex CLI: ${CODEX_STATUS}" >&2
 echo "  gemini CLI: ${GEMINI_STATUS}" >&2
+echo "  RTK CLI:      ${RTK_STATUS}" >&2
 echo "  Agent Teams: ${AGENT_TEAMS_STATUS}" >&2
 echo "  Claude Code: v${CLAUDE_VERSION} (${COMPAT_STATUS})" >&2
 if [ "$COMPAT_STATUS" = "outdated" ]; then

package/templates/.claude/skills/de-lead-routing/SKILL.md

@@ -64,7 +64,7 @@ Check if Agent Teams is available (`CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` or T
 ### Step 2: Codex-Exec Hybrid (Code Generation)
 For **new pipeline code**, **DAG scaffolding**, or **SQL model generation**:
 
-1. Check `/tmp/.claude-env-status-*` for codex and gemini availability
+1. Check `/tmp/.claude-env-status-*` for codex, gemini, and rtk availability
 2. If codex available AND task involves new file creation → automatically delegate to `/codex-exec` for scaffolding:
    - Display: `[Codex Hybrid] Delegating to codex-exec...`
    - codex-exec generates initial code (strength: fast generation)
@@ -73,7 +73,10 @@ For **new pipeline code**, **DAG scaffolding**, or **SQL model generation**:
    - Display: `[Gemini Hybrid] Delegating to gemini-exec...`
    - gemini-exec generates initial code
    - Selected DE expert reviews and refines output
-4. If neither available → display `[External CLI] Unavailable — proceeding with {expert} directly` and use DE expert directly
+4. If RTK available (`RTK=available` in env status) → optionally wrap DE expert output through RTK to reduce token consumption by 60-90%:
+   - Display: `[RTK Proxy] Token optimization active via rtk-exec`
+   - RTK acts as a transparent proxy — no change to expert selection
+5. If none available → display `[External CLI] Unavailable — proceeding with {expert} directly` and use DE expert directly
 
 **Suitable**: New DAG files, dbt model scaffolding, SQL template generation
 **Unsuitable**: Existing pipeline modification, architecture decisions, data quality analysis

package/templates/.claude/skills/dev-lead-routing/SKILL.md

@@ -99,7 +99,7 @@ Check if Agent Teams is available (`CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` or T
 ### Step 2: Codex-Exec Hybrid (Implementation Tasks)
 For **new file creation**, **boilerplate**, or **test code generation**:
 
-1. Check `/tmp/.claude-env-status-*` for codex and gemini availability
+1. Check `/tmp/.claude-env-status-*` for codex, gemini, and rtk availability
 2. If codex available AND task involves new file creation → automatically delegate to `/codex-exec` for scaffolding:
    - Display: `[Codex Hybrid] Delegating to codex-exec...`
    - codex-exec generates initial code (strength: fast generation)
@@ -108,7 +108,10 @@ For **new file creation**, **boilerplate**, or **test code generation**:
    - Display: `[Gemini Hybrid] Delegating to gemini-exec...`
    - gemini-exec generates initial code
    - Selected Claude expert reviews and refines output
-4. If neither available → display `[External CLI] Unavailable — proceeding with {expert} directly` and use Claude expert directly
+4. If RTK available (`RTK=available` in env status) → optionally wrap Claude expert output through RTK to reduce token consumption by 60-90%:
+   - Display: `[RTK Proxy] Token optimization active via rtk-exec`
+   - RTK acts as a transparent proxy — no change to expert selection
+5. If none available → display `[External CLI] Unavailable — proceeding with {expert} directly` and use Claude expert directly
 
 **Suitable**: New file creation, boilerplate, scaffolding, test code
 **Unsuitable**: Existing code modification, architecture decisions, bug fixes

package/templates/.claude/skills/intent-detection/patterns/agent-triggers.yaml

@@ -428,3 +428,11 @@ agents:
     actions: [review, analyze]
     base_confidence: 85
     routing_rule: "MUST use professor-triage skill for cross-analyzing GitHub issues with omc_issue_analyzer comments"
+
+  rtk-exec:
+    keywords:
+      korean: [rtk, 토큰절감, 출력압축, 토큰최적화]
+      english: [rtk, "token savings", "compress output", "token optimization"]
+    file_patterns: []
+    supported_actions: [optimize, compress, proxy]
+    base_confidence: 85

package/templates/.claude/skills/rtk-exec/SKILL.md

@@ -0,0 +1,199 @@
+---
+name: rtk-exec
+description: Execute CLI commands through RTK proxy for token-optimized output
+scope: core
+argument-hint: "<command> [args...] [--gain] [--version] [--init]"
+user-invocable: true
+---
+
+# RTK Exec Skill
+
+Execute CLI commands through the RTK (Rust Token Killer) proxy to reduce LLM token consumption by 60-90%. RTK is a CLI command proxy — it wraps existing shell commands and compresses their output using smart filtering, grouping, truncation, and deduplication.
+
+> **Important**: RTK is NOT an AI prompt tool. It is a CLI output compressor. You pass it a regular shell command and it returns compressed output.
+
+## Options
+
+```
+<command> [args...]   Required. CLI command to proxy through RTK (e.g., "ls .", "git status", "cargo test")
+--gain               Show token savings statistics (rtk gain)
+--version            Show RTK version (rtk --version)
+--init               Initialize RTK for current project (rtk init -g)
+--timeout <ms>       Execution timeout (default: 120000, max: 600000)
+--working-dir <dir>  Working directory for command execution
+```
+
+## Workflow
+
+```
+1. Pre-checks
+   - Verify `rtk` binary is installed (which rtk)
+   - No authentication required
+2. Build command
+   - Special: rtk gain | rtk --version | rtk init -g
+   - Proxy: rtk <command> [args...]
+3. Execute
+   - Run via Bash tool with timeout (default 2min, max 10min)
+   - Or use helper script: node .claude/skills/rtk-exec/scripts/rtk-wrapper.cjs
+4. Parse output
+   - RTK always returns plain text compressed output (no JSON modes)
+   - Capture stdout and stderr
+5. Report results
+   - Format output with execution metadata and token savings info
+```
+
+## Supported Commands
+
+RTK supports 100+ CLI commands across categories:
+
+| Category | Commands |
+|----------|----------|
+| File ops | `ls`, `find`, `grep`, `cat`, `tree`, `du`, `diff` |
+| Git | `git status`, `git log`, `git diff`, `git push`, `git pull`, `git branch` |
+| Test runners | `cargo test`, `pytest`, `vitest`, `jest`, `go test`, `bun test` |
+| Linters | `eslint`, `tsc`, `ruff`, `clippy`, `golangci-lint`, `rubocop` |
+| Package managers | `pnpm install`, `pip install`, `cargo build`, `npm install` |
+| Containers | `docker build`, `docker ps`, `kubectl get`, `kubectl logs` |
+| Build tools | `make`, `cmake`, `gradle`, `mvn` |
+| System | `ps`, `top`, `df`, `netstat`, `env` |
+
+## Output Format
+
+### Success
+```
+[RTK Exec] Completed
+
+Command: rtk git status
+Duration: 0.3s
+Working Dir: /path/to/project
+
+--- Output ---
+{rtk compressed output}
+```
+
+### Success (--gain)
+```
+[RTK Exec] Token Savings
+
+--- Gain Report ---
+{rtk gain statistics showing tokens saved per command}
+```
+
+### Failure
+```
+[RTK Exec] Failed
+
+Command: rtk cargo test
+Error: {error_message}
+Exit Code: {code}
+Stderr: {stderr}
+Suggested Fix: {suggestion}
+```
+
+## Helper Script
+
+For complex executions or programmatic use:
+```bash
+node .claude/skills/rtk-exec/scripts/rtk-wrapper.cjs --command "cargo test" [options]
+```
+
+The wrapper provides:
+- Binary availability check
+- Safe command construction
+- Timeout handling with graceful SIGTERM → SIGKILL escalation
+- Structured JSON output for programmatic consumption
+
+## Examples
+
+```bash
+# List files with compression
+/rtk-exec "ls -la src/"
+
+# Git status (often 70%+ token reduction)
+/rtk-exec "git status"
+
+# Run Rust tests
+/rtk-exec "cargo test"
+
+# Run Python tests
+/rtk-exec "pytest tests/ -v"
+
+# TypeScript type check
+/rtk-exec "tsc --noEmit"
+
+# Show token savings stats
+/rtk-exec --gain
+
+# Initialize RTK for project
+/rtk-exec --init
+
+# With timeout override
+/rtk-exec "cargo build --release" --timeout 300000
+
+# Specify working directory
+/rtk-exec "git log --oneline -20" --working-dir /path/to/repo
+```
+
+## Integration
+
+Works with the orchestrator pattern:
+- Main conversation delegates CLI execution via this skill
+- Results are returned to the main conversation for further processing
+- Particularly effective for test runs, lint checks, and git operations where output is verbose
+- Can be chained: rtk-exec for output collection → Claude expert for analysis
+
+## Availability Check
+
+rtk-exec requires the RTK binary to be installed. The skill is only usable when:
+
+1. `rtk` binary is found in PATH (`which rtk` succeeds)
+2. No authentication or API keys required
+
+If the binary check fails, this skill cannot be used. Fall back to direct Bash tool execution.
+
+> **Note**: This skill is invoked via `/rtk-exec` command or delegated by the orchestrator. It is most useful for any task that produces verbose CLI output that would otherwise consume large amounts of context tokens.
+
+## Agent Teams Integration
+
+When used within Agent Teams:
+
+1. **As delegated task**: orchestrator explicitly delegates CLI execution for token-efficient output
+2. **Hybrid workflow**: Claude team member plans → rtk-exec runs commands → Claude analyzes compressed output
+3. **Batch execution**: Multiple rtk-exec invocations in parallel for different commands
+
+```
+Orchestrator delegates CLI task
+  → /rtk-exec invoked with command
+  → Compressed output returned to orchestrator
+  → Analyst processes compressed result
+  → Iterate if needed
+```
+
+## Token Savings
+
+RTK uses four compression strategies:
+
+| Strategy | Description | Typical Savings |
+|----------|-------------|-----------------|
+| Smart Filtering | Removes redundant/noise lines based on command type | 30-50% |
+| Grouping | Collapses repeated patterns into summary counts | 20-40% |
+| Truncation | Clips excessively long lines with ellipsis | 10-20% |
+| Deduplication | Removes identical repeated output blocks | 15-30% |
+
+Combined effect: **60-90% token reduction** on typical CLI output (git log, test results, lint reports).
+
+## Installation
+
+```bash
+# macOS via Homebrew
+brew install rtk
+
+# Universal install script
+curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh
+
+# From source via Cargo
+cargo install --git https://github.com/rtk-ai/rtk
+
+# Verify installation
+rtk --version
+```

package/templates/.claude/skills/rtk-exec/scripts/rtk-wrapper.cjs

@@ -0,0 +1,377 @@
+#!/usr/bin/env node
+
+/**
+ * rtk-wrapper.cjs
+ *
+ * Node.js wrapper for RTK (Rust Token Killer) CLI proxy.
+ * Executes shell commands through RTK for token-optimized compressed output.
+ *
+ * Usage:
+ *   node rtk-wrapper.cjs --command "git status" [options]
+ *   node rtk-wrapper.cjs --gain
+ *   node rtk-wrapper.cjs --version
+ *   node rtk-wrapper.cjs --init
+ *
+ * Options:
+ *   --command <cmd>       Required (unless --gain/--version/--init): CLI command to proxy through RTK
+ *   --timeout <ms>        Execution timeout in milliseconds (default: 120000, max: 600000)
+ *   --working-dir <dir>   Set working directory for execution
+ *   --gain                Show token savings statistics (rtk gain)
+ *   --version             Show RTK version (rtk --version)
+ *   --init                Initialize RTK for current project (rtk init -g)
+ *
+ * Output (JSON to stdout):
+ *   Success: { "success": true, "output": "...", "duration_ms": 1234, "command": "..." }
+ *   Failure: { "success": false, "error": "...", "stderr": "...", "exit_code": 1 }
+ *
+ * Exit codes:
+ *   0 = success
+ *   1 = execution error
+ *   2 = validation error (missing binary or invalid arguments)
+ */
+
+const { spawn, execFileSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Configuration
+const DEFAULT_TIMEOUT_MS = 120000; // 2 minutes
+const MAX_TIMEOUT_MS = 600000; // 10 minutes
+const KILL_GRACE_PERIOD_MS = 5000; // 5 seconds for graceful shutdown
+
+/**
+ * Parse command line arguments
+ * @returns {Object} Parsed arguments
+ */
+function parseArgs() {
+  const args = {
+    command: null,
+    timeout: DEFAULT_TIMEOUT_MS,
+    workingDir: null,
+    gain: false,
+    version: false,
+    init: false,
+  };
+
+  for (let i = 2; i < process.argv.length; i++) {
+    const arg = process.argv[i];
+
+    switch (arg) {
+      case '--command':
+        if (i + 1 < process.argv.length) {
+          args.command = process.argv[++i];
+        }
+        break;
+      case '--timeout':
+        if (i + 1 < process.argv.length) {
+          const timeoutValue = parseInt(process.argv[++i], 10);
+          if (!isNaN(timeoutValue)) {
+            args.timeout = Math.min(timeoutValue, MAX_TIMEOUT_MS);
+          }
+        }
+        break;
+      case '--working-dir':
+        if (i + 1 < process.argv.length) {
+          args.workingDir = process.argv[++i];
+        }
+        break;
+      case '--gain':
+        args.gain = true;
+        break;
+      case '--version':
+        args.version = true;
+        break;
+      case '--init':
+        args.init = true;
+        break;
+    }
+  }
+
+  return args;
+}
+
+/**
+ * Validate environment for RTK execution
+ * No auth required — only checks binary availability
+ * @returns {Object} Validation result { valid: boolean, errors: string[], rtkPath: string|null }
+ */
+function validateEnvironment() {
+  const errors = [];
+  let rtkPath = null;
+
+  // Check for rtk binary
+  try {
+    const result = execFileSync('which', ['rtk'], { stdio: 'pipe' });
+    rtkPath = result.toString().trim();
+  } catch (error) {
+    // Try common installation paths
+    const commonPaths = [
+      '/usr/local/bin/rtk',
+      path.join(os.homedir(), '.local', 'bin', 'rtk'),
+      path.join(os.homedir(), 'bin', 'rtk'),
+      path.join(os.homedir(), '.cargo', 'bin', 'rtk'),
+      '/opt/homebrew/bin/rtk',
+    ];
+
+    const foundPath = commonPaths.find(p => fs.existsSync(p));
+    if (foundPath) {
+      rtkPath = foundPath;
+    } else {
+      errors.push(
+        'rtk binary not found in PATH or common locations. ' +
+        'Install with: brew install rtk, ' +
+        'curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh, ' +
+        'or cargo install --git https://github.com/rtk-ai/rtk'
+      );
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+    rtkPath,
+  };
+}
+
+/**
+ * Build RTK command array
+ * @param {Object} options - Parsed arguments
+ * @returns {Object} Command structure { binary: string, args: string[], label: string }
+ */
+function buildCommand(options) {
+  // Special commands
+  if (options.gain) {
+    return { binary: 'rtk', args: ['gain'], label: 'rtk gain' };
+  }
+
+  if (options.version) {
+    return { binary: 'rtk', args: ['--version'], label: 'rtk --version' };
+  }
+
+  if (options.init) {
+    return { binary: 'rtk', args: ['init', '-g'], label: 'rtk init -g' };
+  }
+
+  // Proxy command: rtk <command_parts...>
+  // Split the command string into parts for safe argv construction
+  const commandParts = splitCommand(options.command);
+  return {
+    binary: 'rtk',
+    args: commandParts,
+    label: `rtk ${options.command}`,
+  };
+}
+
+/**
+ * Split a command string into argv parts, respecting quoted strings
+ * Simple shell-like splitting (no full POSIX parsing)
+ * @param {string} cmd - Command string
+ * @returns {string[]} Argv parts
+ */
+function splitCommand(cmd) {
+  const parts = [];
+  let current = '';
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+
+  for (let i = 0; i < cmd.length; i++) {
+    const ch = cmd[i];
+
+    if (ch === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote;
+    } else if (ch === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+    } else if (ch === ' ' && !inSingleQuote && !inDoubleQuote) {
+      if (current.length > 0) {
+        parts.push(current);
+        current = '';
+      }
+    } else {
+      current += ch;
+    }
+  }
+
+  if (current.length > 0) {
+    parts.push(current);
+  }
+
+  return parts;
+}
+
+/**
+ * Execute RTK command
+ * @param {string} binary - Binary to execute (rtk)
+ * @param {string[]} args - Command arguments
+ * @param {number} timeout - Timeout in milliseconds
+ * @param {string|null} workingDir - Working directory
+ * @returns {Promise<Object>} Execution result
+ */
+function executeRtk(binary, args, timeout, workingDir = null) {
+  return new Promise((resolve) => {
+    const startTime = Date.now();
+    let stdout = '';
+    let stderr = '';
+    let timedOut = false;
+
+    const spawnOptions = {
+      cwd: workingDir || process.cwd(),
+      env: process.env,
+    };
+
+    const child = spawn(binary, args, spawnOptions);
+
+    // Collect output
+    child.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    child.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    // Set timeout
+    const timeoutHandle = setTimeout(() => {
+      timedOut = true;
+      console.error('[rtk-wrapper] Timeout reached, terminating process...');
+
+      // Graceful termination attempt
+      child.kill('SIGTERM');
+
+      // Force kill after grace period
+      setTimeout(() => {
+        if (!child.killed) {
+          console.error('[rtk-wrapper] Force killing process...');
+          child.kill('SIGKILL');
+        }
+      }, KILL_GRACE_PERIOD_MS);
+    }, timeout);
+
+    // Handle process exit
+    child.on('close', (exitCode) => {
+      clearTimeout(timeoutHandle);
+      const durationMs = Date.now() - startTime;
+
+      resolve({
+        exitCode: exitCode !== null ? exitCode : 1,
+        stdout,
+        stderr,
+        timedOut,
+        durationMs,
+      });
+    });
+
+    // Handle spawn errors
+    child.on('error', (error) => {
+      clearTimeout(timeoutHandle);
+      const durationMs = Date.now() - startTime;
+
+      resolve({
+        exitCode: 1,
+        stdout,
+        stderr: stderr + '\nSpawn error: ' + error.message,
+        timedOut: false,
+        durationMs,
+      });
+    });
+  });
+}
+
+/**
+ * Main execution function
+ */
+async function main() {
+  const args = parseArgs();
+
+  // Determine which mode we're running in
+  const isSpecialCommand = args.gain || args.version || args.init;
+
+  // Validate required arguments
+  if (!isSpecialCommand && !args.command) {
+    const result = {
+      success: false,
+      error: 'Missing required argument: --command (or use --gain, --version, --init)',
+      exit_code: 2,
+    };
+    console.log(JSON.stringify(result, null, 2));
+    process.exit(2);
+  }
+
+  // Validate environment (binary check only, no auth)
+  const validation = validateEnvironment();
+  if (!validation.valid) {
+    const result = {
+      success: false,
+      error: 'RTK binary not found',
+      validation_errors: validation.errors,
+      exit_code: 2,
+    };
+    console.log(JSON.stringify(result, null, 2));
+    process.exit(2);
+  }
+
+  console.error(`[rtk-wrapper] RTK binary: ${validation.rtkPath}`);
+  console.error(`[rtk-wrapper] Executing with timeout: ${args.timeout}ms`);
+  if (args.workingDir) {
+    console.error(`[rtk-wrapper] Working directory: ${args.workingDir}`);
+  }
+
+  // Build command
+  const command = buildCommand(args);
+  console.error(`[rtk-wrapper] Command: ${command.binary} ${command.args.join(' ')}`);
+
+  // Execute
+  const execResult = await executeRtk(
+    command.binary,
+    command.args,
+    args.timeout,
+    args.workingDir
+  );
+
+  // Determine success
+  const success = execResult.exitCode === 0 && !execResult.timedOut;
+
+  // Build result object
+  const result = {
+    success,
+    duration_ms: execResult.durationMs,
+    exit_code: execResult.exitCode,
+    command: command.label,
+  };
+
+  if (success) {
+    result.output = execResult.stdout.trim();
+    if (execResult.stderr.trim()) {
+      result.stderr = execResult.stderr.trim();
+    }
+  } else {
+    if (execResult.timedOut) {
+      result.error = `Execution timed out after ${args.timeout}ms`;
+    } else {
+      result.error = 'Execution failed';
+    }
+    if (execResult.stderr.trim()) {
+      result.stderr = execResult.stderr.trim();
+    }
+    if (execResult.stdout.trim()) {
+      result.partial_output = execResult.stdout.trim();
+    }
+  }
+
+  // Output JSON result to stdout
+  console.log(JSON.stringify(result, null, 2));
+
+  process.exit(result.exit_code);
+}
+
+// Run
+main().catch(error => {
+  const result = {
+    success: false,
+    error: 'Unexpected error: ' + error.message,
+    stack: error.stack,
+    exit_code: 1,
+  };
+  console.log(JSON.stringify(result, null, 2));
+  process.exit(1);
+});

package/templates/CLAUDE.md

@@ -120,6 +120,7 @@ oh-my-customcode로 구동됩니다.
 | `/omcustom-feedback` | 사용자 피드백을 GitHub Issue로 등록 |
 | `/codex-exec` | Codex CLI 프롬프트 실행 |
 | `/gemini-exec` | Gemini CLI 프롬프트 실행 |
+| `/rtk-exec` | RTK CLI 프록시 실행 (토큰 압축) |
 | `/optimize-analyze` | 번들 및 성능 분석 |
 | `/optimize-bundle` | 번들 크기 최적화 |
 | `/optimize-report` | 최적화 리포트 생성 |
@@ -149,7 +150,7 @@ project/
 +-- CLAUDE.md                    # 진입점
 +-- .claude/
 |   +-- agents/                  # 서브에이전트 정의 (46 파일)
-|   +-- skills/                  # 스킬 (99 디렉토리)
+|   +-- skills/                  # 스킬 (100 디렉토리)
 |   +-- rules/                   # 전역 규칙 (R000-R021)
 |   +-- hooks/                   # 훅 스크립트 (보안, 검증, HUD)
 |   +-- contexts/                # 컨텍스트 파일 (ecomode)

package/templates/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.66.0",
+  "version": "0.67.0",
   "lastUpdated": "2026-03-24T00:00:00.000Z",
   "components": [
     {
@@ -18,7 +18,7 @@
       "name": "skills",
       "path": ".claude/skills",
       "description": "Reusable skill modules (includes slash commands)",
-      "files": 99
+      "files": 100
     },
     {
       "name": "guides",