claude-pro-minmax 1.3.0 → 1.3.1

package/README.ko.md

@@ -16,14 +16,14 @@ CPMM은 모델 라우팅, 출력 제어, 로컬 안전장치로 리셋 전까지
 
 > **설치 완료했다면 여기서 시작하세요: [사용자 가이드](docs/USER-MANUAL.ko.md)**
 >
-> **New in v1.3.0:** Bash-heavy 출력 축약을 위한 RTK 선택 통합.
+> **New in v1.3.1:** RTK를 이미 켜둔 사용자에 대해 `cpmm setup`이 관리된 hook 순서와 timeout을 자동 복원합니다.
 
 ---
 
 > [!TIP]
 > **🚀 3초 요약: 왜 이걸 써야 하나요?**
 > 1.  **배치 실행:** `/do`로 구현-검증을 한 흐름에서 처리하고, 필요할 때만 `/do-sonnet`/`/do-opus`로 승격합니다.
-> 2.  **출력 비용 제어:** 응답 예산, CLI 필터링, 그리고 optional RTK로 Bash-heavy 출력량을 줄입니다.
+> 2.  **출력 비용 제어:** 응답 예산, CLI 필터링, 그리고 optional RTK로 Bash 출력이 Claude 입력 컨텍스트를 불필요하게 키우지 않도록 합니다.
 > 3.  **로컬 안전장치:** 로컬 Hook + 원자적 롤백으로 실패 시 빠르게 복구합니다.
 
 ---
@@ -52,7 +52,7 @@ cpmm setup
 cpmm doctor
 ```
 
-> **v1.3.0 참고:** `cpmm setup`은 지원 환경에서 RTK 설치를 시도합니다. RTK 활성화는 여전히 opt-in입니다.
+> **v1.3.1 참고:** `cpmm setup`은 지원 환경에서 RTK 설치를 계속 시도합니다. RTK 활성화는 여전히 opt-in이지만, 한 번 켠 뒤에는 CPMM이 관리된 hook 순서와 timeout을 자동 복원합니다.
 
 의존성 정책:
 - `required`: `jq`, `mgrep`, `tmux`
@@ -101,7 +101,45 @@ cpmm doctor
 프로젝트 초기화 팁:
 - `claude` 실행 전에 `project-templates/`를 참고해 프로젝트를 초기화하세요. (설치기는 `project-templates`를 `~/.claude`로 복사하지 않습니다.)
 
-### 5. 고급 (선택)
+### 5. Bash 명령 출력 필터링 (RTK)
+
+RTK는 CPMM이 지원하는 **선택적 Bash 명령 출력 필터링 계층**입니다. `cpmm setup`은 RTK 바이너리 설치를 시도하지만, RTK hook은 기본 활성화하지 않습니다.
+
+RTK를 이번 릴리스에 선택 통합으로 넣은 이유는, Bash-heavy 워크플로우에서 긴 명령 출력이 Claude 입력 컨텍스트로 다시 들어가기 전에 이를 줄여 주기 때문입니다. CPMM은 권장 hook 순서를 문서화하고 `cpmm doctor`로 점검하며, 그 순서에서는 CPMM의 critical-action check가 RTK rewrite hook보다 먼저 실행되어야 합니다. 다만 hook 동작을 예측 가능하고 디버깅 가능하게 유지하기 위해 default-on이 아니라 opt-in으로 제공합니다.
+
+권장 opt-in 절차:
+
+```bash
+rtk init -g --hook-only
+# RTK를 켠 뒤에는 cpmm setup이 관리된 hook 순서와 timeout을 복원
+cpmm setup
+cpmm doctor
+```
+
+권장 `PreToolUse` 순서 (`~/.claude/settings.json`):
+- 먼저 CPMM safety hook: `~/.claude/scripts/hooks/critical-action-check.sh` with `timeout: 5`
+- 그 다음 RTK rewrite hook: `~/.claude/hooks/rtk-rewrite.sh` with `timeout: 10`
+
+업데이트 참고:
+- `cpmm setup`은 업데이트 시 `~/.claude/settings.json`을 다시 씁니다.
+- `cpmm setup` 전에 RTK가 이미 켜져 있었다면, CPMM이 설정 재작성 뒤에 관리된 RTK hook 순서와 `timeout: 10`을 자동 복원합니다.
+- 관리된 RTK 상태를 확인하려면 setup 뒤에 `cpmm doctor`를 실행하세요.
+
+권장 검증:
+- `/hooks`에서 CPMM hook과 RTK hook이 모두 로드되는지 확인
+- 위험 명령이 여전히 CPMM에서 먼저 차단되는지 확인
+- `cpmm doctor` 실행
+- 실제 Bash-heavy 세션 후 `rtk gain --quota --tier pro` 확인
+
+공개된 [RTK 통합 사용자 사례](https://github.com/move-hoon/claude-pro-minmax/issues/3)에서는 `rtk gain --quota --tier pro` 기준으로 Bash-heavy 워크플로우에서 `1,664`개 명령 동안 입력 토큰 `8.5M` 절감(`49.4%`)이 보고되었습니다. 절감률은 작업 부하와 세션 형태에 따라 달라질 수 있습니다.
+
+롤백:
+
+```bash
+rtk init -g --uninstall
+```
+
+### 6. 고급 (선택)
 <details>
 <summary>Perplexity, 언어, 수동 설치 보기</summary>
 
@@ -154,37 +192,6 @@ node bin/cpmm.js setup
 
 </details>
 
-### 6. Bash 출력 최적화 (RTK)
-
-RTK는 CPMM이 지원하는 **선택적 출력 최적화 계층**입니다. `cpmm setup`은 RTK 바이너리 설치를 시도하지만, RTK hook은 기본 활성화하지 않습니다.
-
-권장 opt-in 절차:
-
-```bash
-rtk init -g --hook-only
-cpmm doctor
-```
-
-권장 `PreToolUse` 순서 (`~/.claude/settings.json`):
-- 먼저 CPMM safety hook: `~/.claude/scripts/hooks/critical-action-check.sh` with `timeout: 5`
-- 그 다음 RTK rewrite hook: `~/.claude/hooks/rtk-rewrite.sh` with `timeout: 10`
-
-업데이트 참고:
-- `cpmm setup`은 업데이트 시 `~/.claude/settings.json`을 다시 씁니다.
-- RTK를 opt-in으로 사용 중이면 CPMM 업데이트 후 hook 순서와 timeout을 다시 확인하고, `cpmm doctor`를 다시 실행하세요.
-
-권장 검증:
-- `/hooks`에서 CPMM hook과 RTK hook이 모두 로드되는지 확인
-- 위험 명령이 여전히 CPMM에서 먼저 차단되는지 확인
-- `cpmm doctor` 실행
-- 실제 Bash-heavy 세션 후 `rtk gain --quota --tier pro` 확인
-
-롤백:
-
-```bash
-rtk init -g --uninstall
-```
-
 ---
 
 ## 🚀 빠른 시작 (Quick Start)
@@ -461,7 +468,7 @@ claude-pro-minmax
 
 A: Anthropic의 정확한 quota 알고리즘은 공개되지 않았습니다. 세 가지 축으로 최적화합니다:
 - **저비용 모델 우선 경로**: 기본 구현은 Haiku 중심으로 시작하고 필요 시에만 Sonnet/Opus로 승격합니다.
-- **출력 비용 인식**: Output 토큰은 Input 대비 단가가 높아 응답 예산/필터링으로 payload를 줄입니다.
+- **출력 비용 인식**: 출력이 많은 턴일수록 비용 부담이 커지는 경향이 있으므로, 응답 예산과 필터링으로 payload를 줄입니다.
 - **작업 흐름 단순화**: `/do`와 `/plan`을 상황에 맞게 분리해 불필요한 고비용 턴을 줄입니다.
 
 근거 실측값은 [docs/CORE_STRATEGY_EXPERIMENT_ARCHIVE.ko.md](docs/CORE_STRATEGY_EXPERIMENT_ARCHIVE.ko.md)를 참고하세요.

package/README.md

@@ -16,14 +16,14 @@ CPMM helps Pro users complete more verified tasks before reset through model rou
 
 > **Already installed? Start here: [User Guide](docs/USER-MANUAL.md)**
 >
-> **New in v1.3.0:** Optional RTK integration for Bash-heavy output reduction.
+> **New in v1.3.1:** `cpmm setup` now restores the managed RTK hook order and timeout for users who already enabled RTK.
 
 ---
 
 > [!TIP]
 > **🚀 3-Second Summary: Why use this?**
 > 1.  **Batch Execution:** Use `/do` to keep implementation and verification in one flow, and escalate to `/do-sonnet`/`/do-opus` only when needed.
-> 2.  **Output Cost Control:** Use response budgets, CLI filtering, and optional RTK for Bash-heavy output reduction.
+> 2.  **Output Cost Control:** Use response budgets, CLI filtering, and optional RTK to keep Bash output from inflating Claude input context.
 > 3.  **Local Safety Rails:** Local hooks and atomic rollback help you recover quickly on failure.
 
 ---
@@ -52,7 +52,7 @@ cpmm setup
 cpmm doctor
 ```
 
-> **v1.3.0 note:** `cpmm setup` now attempts RTK installation when supported. RTK activation remains opt-in.
+> **v1.3.1 note:** `cpmm setup` still attempts RTK installation when supported. RTK activation remains opt-in, but once enabled CPMM now restores the managed hook order and timeout automatically.
 
 Dependency policy:
 - `required`: `jq`, `mgrep`, `tmux`
@@ -101,7 +101,45 @@ Dependency policy:
 Project initialization tip:
 - Before running `claude`, initialize your project with templates in `project-templates/` (not copied into `~/.claude`).
 
-### 5. Advanced (Optional)
+### 5. Bash Command-Output Filtering (RTK)
+
+CPMM supports RTK as an **optional Bash command-output filtering layer** for Bash-heavy workflows. `cpmm setup` attempts to install the RTK binary, but CPMM does **not** enable the RTK hook by default.
+
+We’re shipping RTK as an official optional integration because it reduces noisy command output before that output expands Claude’s input context in Bash-heavy workflows. CPMM documents and validates the recommended hook order, where CPMM’s critical-action check should run before RTK’s rewrite hook. The integration remains opt-in so hook behavior stays predictable and easier to debug.
+
+Recommended opt-in flow:
+
+```bash
+rtk init -g --hook-only
+# if RTK was enabled, cpmm setup restores the managed hook order + timeout
+cpmm setup
+cpmm doctor
+```
+
+Recommended `PreToolUse` order in `~/.claude/settings.json`:
+- CPMM safety hook first: `~/.claude/scripts/hooks/critical-action-check.sh` with `timeout: 5`
+- RTK rewrite hook second: `~/.claude/hooks/rtk-rewrite.sh` with `timeout: 10`
+
+Update note:
+- `cpmm setup` rewrites `~/.claude/settings.json` on update.
+- If RTK was already enabled before `cpmm setup`, CPMM restores the managed RTK hook order and `timeout: 10` automatically after rewriting settings.
+- Run `cpmm doctor` after setup if you want to verify the managed RTK state.
+
+Recommended verification:
+- Run `/hooks` and confirm both CPMM and RTK hooks are loaded
+- Confirm dangerous commands are still blocked by CPMM
+- Run `cpmm doctor`
+- After real Bash-heavy sessions, inspect `rtk gain --quota --tier pro`
+
+Public example: in a [community RTK integration report](https://github.com/move-hoon/claude-pro-minmax/issues/3), `rtk gain --quota --tier pro` reported `8.5M` input tokens saved (`49.4%`) across `1,664` commands in a Bash-heavy workflow. Savings vary by workload and session shape.
+
+Rollback:
+
+```bash
+rtk init -g --uninstall
+```
+
+### 6. Advanced (Optional)
 <details>
 <summary>Perplexity, language, manual install</summary>
 
@@ -154,37 +192,6 @@ node bin/cpmm.js setup
 
 </details>
 
-### 6. Bash Output Optimization (RTK)
-
-CPMM supports RTK as an **optional output-optimization layer** for Bash-heavy workflows. `cpmm setup` attempts to install the RTK binary, but CPMM does **not** enable the RTK hook by default.
-
-Recommended opt-in flow:
-
-```bash
-rtk init -g --hook-only
-cpmm doctor
-```
-
-Recommended `PreToolUse` order in `~/.claude/settings.json`:
-- CPMM safety hook first: `~/.claude/scripts/hooks/critical-action-check.sh` with `timeout: 5`
-- RTK rewrite hook second: `~/.claude/hooks/rtk-rewrite.sh` with `timeout: 10`
-
-Update note:
-- `cpmm setup` rewrites `~/.claude/settings.json` on update.
-- If you opt into RTK, re-check hook order and timeout after each CPMM update, then run `cpmm doctor`.
-
-Recommended verification:
-- Run `/hooks` and confirm both CPMM and RTK hooks are loaded
-- Confirm dangerous commands are still blocked by CPMM
-- Run `cpmm doctor`
-- After real Bash-heavy sessions, inspect `rtk gain --quota --tier pro`
-
-Rollback:
-
-```bash
-rtk init -g --uninstall
-```
-
 ---
 
 ## 🚀 Quick Start
@@ -461,7 +468,7 @@ To add a new runtime, copy and implement `scripts/runtime/adapters/_template.sh`
 
 A: Anthropic's exact quota algorithm is not public. Optimization is based on three pillars:
 - **Low-cost model-first path**: Start implementation with Haiku, and escalate to Sonnet/Opus only when needed.
-- **Output-cost awareness**: Output tokens are priced higher than input, so response budgets/filtering reduce payload.
+- **Output-cost awareness**: Output-heavy turns tend to cost more, so response budgets and filtering help keep payloads smaller.
 - **Workflow simplification**: Use `/do` and `/plan` by task type to avoid unnecessary high-cost turns.
 
 For measured evidence, see [docs/CORE_STRATEGY_EXPERIMENT_ARCHIVE.md](docs/CORE_STRATEGY_EXPERIMENT_ARCHIVE.md).

package/install.sh

@@ -304,8 +304,13 @@ fi
 if [ "$HAS_EXISTING_RTK_HOOK" = true ]; then
   echo "RTK Update Note:"
   echo "  An RTK hook was detected before this CPMM update."
-  echo "  Because CPMM reinstalled ~/.claude/settings.json, re-check RTK hook order and timeout."
-  echo "  Run: cpmm doctor"
+  if [ "${CPMM_SETUP_WRAPPER:-}" = "1" ]; then
+    echo "  cpmm setup will restore the managed RTK hook order and timeout after rewriting settings."
+    echo "  Run: cpmm doctor"
+  else
+    echo "  Re-run cpmm setup to restore the managed RTK hook order and timeout."
+    echo "  Or re-check ~/.claude/settings.json manually, then run: cpmm doctor"
+  fi
   echo ""
 fi
 echo "Language:"

package/lib/cli.js

@@ -9,6 +9,7 @@ const {
   attemptRtkInstall,
   getRtkManualInstallHints,
   inspectRtkStatus,
+  reconcileManagedRtkHook,
 } = require("./rtk");
 
 const DEPS = [
@@ -181,9 +182,26 @@ function printRtkSetupResult(result) {
 
   console.log("  Optional activation:");
   console.log("             1) rtk init -g --hook-only");
-  console.log("             2) Add ~/.claude/hooks/rtk-rewrite.sh after CPMM critical-action-check.sh");
-  console.log("             3) Set RTK hook timeout to 10");
-  console.log("             4) Re-run: cpmm doctor");
+  console.log("             2) Re-run cpmm setup to restore the CPMM-managed hook order + timeout");
+  console.log("             3) Re-run: cpmm doctor");
+  console.log("");
+}
+
+function printRtkReconcileResult(result) {
+  if (!result || !result.attempted) return;
+
+  if (result.ok) {
+    const suffix = result.changed ? "restored" : "already canonical";
+    console.log("RTK Hook Management:");
+    console.log(`  ${colorize("✓", "32")} managed hook     ${suffix} (CPMM hook first, RTK timeout 10)`);
+    console.log("");
+    return;
+  }
+
+  console.log("RTK Hook Management:");
+  console.log(`  ${colorize("⚠", "33")} managed hook     ${result.message || "unable to restore RTK hook state automatically"}`);
+  console.log("             Run: rtk init -g --hook-only");
+  console.log("             Then: cpmm setup");
   console.log("");
 }
 
@@ -240,6 +258,7 @@ function printRtkDoctorStatus(status) {
   } else {
     const rendered = status.timeoutValue == null ? "missing" : String(status.timeoutValue);
     console.log(`  ${colorize("⚠", "33")} RTK timeout        ${rendered} (recommended: 10)`);
+    console.log("             Fix: re-run cpmm setup to restore the managed timeout");
   }
 
   console.log("");
@@ -248,6 +267,9 @@ function printRtkDoctorStatus(status) {
 
 function runSetup() {
   console.log(`CPMM v${pkg.version} - Setup`);
+  const settingsPath = path.join(process.env.HOME || process.env.USERPROFILE || "", ".claude", "settings.json");
+  const preSetupRtkStatus = inspectRtkStatus(settingsPath);
+  const shouldRestoreManagedRtkHook = preSetupRtkStatus.hookEnabled;
 
   const results = checkDeps();
   const missing = results.filter((r) => r.required && !r.installed);
@@ -285,6 +307,12 @@ function runSetup() {
     return 1;
   }
 
+  const rtkReconcile = reconcileManagedRtkHook({
+    enabledBeforeSetup: shouldRestoreManagedRtkHook,
+    settingsPath,
+  });
+  printRtkReconcileResult(rtkReconcile);
+
   console.log("Setup complete.");
   return 0;
 }
@@ -297,7 +325,7 @@ function runInstallScript() {
   console.log("Configuring CPMM...\n");
   const result = spawnSync("bash", [scriptPath], {
     stdio: "inherit",
-    env: { ...process.env },
+    env: { ...process.env, CPMM_SETUP_WRAPPER: "1" },
   });
   if (result.status !== 0) {
     console.error("Config setup had issues. Run 'bash install.sh' manually if needed.");

package/lib/rtk.js

@@ -9,6 +9,8 @@ const RTK_INSTALL_URL = "https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads
 const RTK_DOCS_URL = "https://github.com/rtk-ai/rtk/blob/main/docs/INSTALL.md";
 const CPMM_HOOK_NAME = "critical-action-check.sh";
 const RTK_HOOK_NAME = "rtk-rewrite.sh";
+const RTK_HOOK_COMMAND = "~/.claude/hooks/rtk-rewrite.sh";
+const RTK_HOOK_TIMEOUT = 10;
 
 function commandExists(cmd) {
   try {
@@ -30,6 +32,10 @@ function runCommand(bin, args, label) {
   return true;
 }
 
+function cloneJson(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
 function getRtkManualInstallHints() {
   return [
     "RTK is optional. CPMM setup will continue without it.",
@@ -114,6 +120,198 @@ function flattenBashHooks(settings) {
   return flattened;
 }
 
+function normalizeManagedRtkHookSettings(settings) {
+  const source = settings && typeof settings === "object" ? settings : {};
+  const next = cloneJson(source);
+  if (!next.hooks || typeof next.hooks !== "object") next.hooks = {};
+  const preToolUse = Array.isArray(next.hooks.PreToolUse) ? next.hooks.PreToolUse : [];
+  next.hooks.PreToolUse = preToolUse;
+
+  let cpmmEntryIndex = -1;
+  let cpmmHookIndex = -1;
+
+  preToolUse.forEach((entry, entryIndex) => {
+    if (!matcherIncludesBash(entry?.matcher)) return;
+    const hooks = Array.isArray(entry?.hooks) ? entry.hooks : [];
+    const foundIndex = hooks.findIndex((hook) => String(hook?.command || "").includes(CPMM_HOOK_NAME));
+    if (foundIndex !== -1 && cpmmEntryIndex === -1) {
+      cpmmEntryIndex = entryIndex;
+      cpmmHookIndex = foundIndex;
+    }
+  });
+
+  if (cpmmEntryIndex === -1 || cpmmHookIndex === -1) {
+    return {
+      ok: false,
+      failReason: "missing_cpmm_hook",
+      changed: false,
+      settings: next,
+    };
+  }
+
+  next.hooks.PreToolUse = preToolUse
+    .map((entry, entryIndex) => {
+      if (!matcherIncludesBash(entry?.matcher)) return entry;
+      const hooks = Array.isArray(entry?.hooks) ? entry.hooks : [];
+      const filteredHooks = hooks.filter((hook) => !String(hook?.command || "").includes(RTK_HOOK_NAME));
+      return {
+        ...entry,
+        hooks: filteredHooks,
+        __cpmmEntry: entryIndex === cpmmEntryIndex,
+      };
+    })
+    .filter((entry) => {
+      if (!matcherIncludesBash(entry?.matcher)) return true;
+      if (entry.__cpmmEntry) return true;
+      return Array.isArray(entry?.hooks) && entry.hooks.length > 0;
+    })
+    .map((entry) => {
+      const { __cpmmEntry, ...rest } = entry;
+      return rest;
+    });
+
+  const canonicalEntry = next.hooks.PreToolUse.find((entry) => {
+    if (!matcherIncludesBash(entry?.matcher)) return false;
+    const hooks = Array.isArray(entry?.hooks) ? entry.hooks : [];
+    return hooks.some((hook) => String(hook?.command || "").includes(CPMM_HOOK_NAME));
+  });
+
+  if (!canonicalEntry) {
+    return {
+      ok: false,
+      failReason: "missing_cpmm_hook",
+      changed: false,
+      settings: next,
+    };
+  }
+
+  const canonicalHooks = Array.isArray(canonicalEntry.hooks) ? canonicalEntry.hooks : [];
+  const canonicalCpmmIndex = canonicalHooks.findIndex((hook) => String(hook?.command || "").includes(CPMM_HOOK_NAME));
+  if (canonicalCpmmIndex === -1) {
+    return {
+      ok: false,
+      failReason: "missing_cpmm_hook",
+      changed: false,
+      settings: next,
+    };
+  }
+
+  const desiredRtkHook = {
+    type: "command",
+    command: RTK_HOOK_COMMAND,
+    timeout: RTK_HOOK_TIMEOUT,
+  };
+
+  canonicalHooks.splice(canonicalCpmmIndex + 1, 0, desiredRtkHook);
+  canonicalEntry.hooks = canonicalHooks;
+
+  return {
+    ok: true,
+    changed: JSON.stringify(source) !== JSON.stringify(next),
+    settings: next,
+    failReason: null,
+  };
+}
+
+function writeSettingsJsonAtomic(settingsPath, settings) {
+  const tempPath = `${settingsPath}.tmp`;
+  fs.writeFileSync(tempPath, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
+  fs.renameSync(tempPath, settingsPath);
+}
+
+function ensureRtkHookArtifact() {
+  const hookPath = path.join(os.homedir(), ".claude", "hooks", RTK_HOOK_NAME);
+  if (fs.existsSync(hookPath)) {
+    return { ok: true, hookPath, initialized: false };
+  }
+
+  const ok = runCommand("rtk", ["init", "-g", "--hook-only", "--no-patch"], "rtk hook init");
+  if (!ok || !fs.existsSync(hookPath)) {
+    return {
+      ok: false,
+      hookPath,
+      initialized: ok,
+      failReason: "missing_rtk_hook_artifact",
+      message: "RTK hook artifact could not be created.",
+    };
+  }
+
+  return { ok: true, hookPath, initialized: true };
+}
+
+function reconcileManagedRtkHook({ enabledBeforeSetup, settingsPath }) {
+  const result = {
+    attempted: Boolean(enabledBeforeSetup),
+    changed: false,
+    ok: true,
+    message: null,
+    failReason: null,
+  };
+
+  if (!enabledBeforeSetup) {
+    return result;
+  }
+
+  if (!commandExists("rtk")) {
+    return {
+      ...result,
+      ok: false,
+      failReason: "rtk_binary_missing",
+      message: "RTK binary is not available, so CPMM could not restore the managed RTK hook.",
+    };
+  }
+
+  if (!fs.existsSync(settingsPath)) {
+    return {
+      ...result,
+      ok: false,
+      failReason: "missing_settings_json",
+      message: "CPMM settings.json is missing after setup.",
+    };
+  }
+
+  const hookArtifact = ensureRtkHookArtifact();
+  if (!hookArtifact.ok) {
+    return {
+      ...result,
+      ok: false,
+      failReason: hookArtifact.failReason || "missing_rtk_hook_artifact",
+      message: hookArtifact.message || "RTK hook artifact could not be created.",
+    };
+  }
+
+  let parsed;
+  try {
+    parsed = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+  } catch {
+    return {
+      ...result,
+      ok: false,
+      failReason: "invalid_settings_json",
+      message: "CPMM settings.json is invalid JSON after setup.",
+    };
+  }
+
+  const normalized = normalizeManagedRtkHookSettings(parsed);
+  if (!normalized.ok) {
+    return {
+      ...result,
+      ok: false,
+      failReason: normalized.failReason,
+      message: "CPMM could not find its Bash safety hook while restoring RTK.",
+    };
+  }
+
+  if (normalized.changed) {
+    writeSettingsJsonAtomic(settingsPath, normalized.settings);
+  }
+
+  return {
+    ...result,
+    changed: normalized.changed,
+  };
+}
+
 function inspectRtkStatus(settingsPath) {
   const result = {
     binaryInstalled: commandExists("rtk"),
@@ -162,7 +360,7 @@ function inspectRtkStatus(settingsPath) {
 
   const rtkHook = hooks[rtkIndex];
   result.timeoutValue = typeof rtkHook.timeout === "number" ? rtkHook.timeout : null;
-  result.timeoutOk = result.timeoutValue === 10;
+  result.timeoutOk = result.timeoutValue === RTK_HOOK_TIMEOUT;
   if (!result.timeoutOk) {
     result.warnings.push("rtk_timeout_not_10");
   }
@@ -173,7 +371,11 @@ function inspectRtkStatus(settingsPath) {
 module.exports = {
   RTK_DOCS_URL,
   RTK_INSTALL_URL,
+  RTK_HOOK_COMMAND,
+  RTK_HOOK_TIMEOUT,
   attemptRtkInstall,
   getRtkManualInstallHints,
   inspectRtkStatus,
+  normalizeManagedRtkHookSettings,
+  reconcileManagedRtkHook,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-pro-minmax",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "Quota-first routing and safety layer for Claude Code Pro workflows.",
   "author": "donghoon <move-hoon@users.noreply.github.com>",
   "license": "MIT",