cckeep 0.1.2 → 0.2.3

package/README.ja.md

@@ -1,11 +1,11 @@
 <div align="center">
-  <img src="https://raw.githubusercontent.com/kamihork/cckeep/main/assets/logo.png" width="140" height="140" alt="cckeep ロゴ — 開いたまま保たれるリンク">
+  <img src="https://raw.githubusercontent.com/kamihork/cckeep/main/assets/logo.png" width="140" height="140" alt="cckeep ロゴ(繋がったままのリンク)">
 
   <h1>cckeep</h1>
 
   <p><strong>Claude Code のリモートコントロールが黙って死ぬのを防ぎます。</strong><br>
-  リモートコントロールは約31秒で再試行を諦め、二度と戻りません。<br>
-  <code>cckeep</code> はそれを検知して繋ぎ直します — 作業中のセッションには触れずに。</p>
+  リモートコントロールは約31秒で再接続を諦め、二度と戻りません。<br>
+  <code>cckeep</code> がそれを検知して繋ぎ直します。作業中のセッションには手を出しません。</p>
 
   <p>
     <a href="https://www.npmjs.com/package/cckeep"><img src="https://img.shields.io/npm/v/cckeep?color=1f9d8f&label=npm" alt="npm version"></a>
@@ -19,31 +19,31 @@
 
 ## 何が問題か
 
-[リモートコントロール](https://code.claude.com/docs/en/remote-control)は、手元で動いている Claude Code のセッションをスマホや claude.ai から操作する機能です。接続が切れても自動で再接続してくれます — ただし **1/2/4/8/16秒のバックオフで5回まで**。合計 **31秒** の予算です。ノートを閉じる、Wi-Fi を切り替える、エレベーターに乗る。それだけで予算は尽き、接続は閉じられて二度と戻りません。
+[リモートコントロール](https://code.claude.com/docs/en/remote-control)は、手元で動いている Claude Code のセッションをスマホや claude.ai から操作する機能です。接続が切れても自動で再接続してくれますが、その回数は **1/2/4/8/16秒の間隔で5回まで**、合計 **31秒**しかありません。ノートを閉じる、Wi-Fi を切り替える、エレベーターに乗る。それだけで再試行は尽き、接続は閉じられて二度と戻りません。
 
-もう一つの壊れ方もあります。`/rc reconnecting` の表示のまま永久に固まるパターンで、これが [anthropics/claude-code#34255](https://github.com/anthropics/claude-code/issues/34255) — 2026年3月から open、👍 99件、未修正です。
+壊れ方はもう一つあります。`/rc reconnecting` の表示のまま、いつまでも動かなくなるパターンです。これが [anthropics/claude-code#34255](https://github.com/anthropics/claude-code/issues/34255) で、2026年3月に報告されてから 👍 99件を集めたまま、まだ直っていません。
 
-どちらにせよ気づき方は同じです。スマホを開いたらセッションが消えている。公式に案内されている復旧方法は、机に戻って `/remote-control` と打つことです。
+どちらの場合も、気づき方は同じです。スマホを開いたらセッションが消えている。そして公式に案内されている復旧方法は、机に戻って `/remote-control` と打つことだけです。
 
 ## クイックスタート
 
 ```sh
 npm install -g cckeep
-cckeep install
+cckeep enable
 ```
 
-バックグラウンドジョブを登録します(macOS は launchd、Linux は systemd user timer)。15秒ごとに確認し、死んでいるものを繋ぎ直します。
+`npm install` は CLI を `PATH` に置くだけで、この時点ではまだ何も動いていません。`cckeep enable` がバックグラウンドジョブを登録し(macOS は launchd、Linux は systemd user timer)、そこから15秒ごとに状態を確認して、切れているものを繋ぎ直すようになります。
 
-`npx cckeep install` ではなくグローバルに入れてください。登録されたジョブはインストール先の cckeep を実行しますが、npx のキャッシュは使い捨てです。そこを指すジョブはキャッシュが消された瞬間に、黙って動かなくなります — 監視ツールが持ってはいけない唯一の壊れ方です。そのため `cckeep install` は npx のパスからの登録を拒否します。
+`npx cckeep enable` ではなく、グローバルに入れてから実行してください。登録されたジョブはインストール先の cckeep をそのまま実行しますが、npx のキャッシュは使い捨てです。そこを指したジョブは、キャッシュが消された瞬間に何も言わず動かなくなります。監視ツールにとって、これがいちばん避けたい壊れ方です。そのため `cckeep enable` は npx のパスからの登録を拒否します。
 
-入れる前に様子を見るだけなら `npx` で構いません。以下の2つは何も変更しません。
+入れる前に様子を見るだけなら `npx` で構いません。次の2つは何も変更しません。
 
 ```sh
 npx cckeep            # いま何が見えているか
 npx cckeep doctor     # tmux・ペイン・スケジューラの確認
 ```
 
-**インストール直後に `command not found: cckeep` と出たら**、shim 方式のバージョン管理ツールを使っています。`nodenv` や `asdf` は新しく入った実行ファイルを PATH に出すのに rehash が必要で、`nvm` はシェルを開き直す必要があります。
+**インストール直後に `command not found: cckeep` と出た場合**、shim 方式のバージョン管理ツールを使っているはずです。`nodenv` や `asdf` では、新しく入った実行ファイルが `PATH` に現れるまでに rehash が必要です。`nvm` の場合はシェルを開き直してください。
 
 ```sh
 nodenv rehash      # nodenv
@@ -51,33 +51,33 @@ asdf reshim nodejs # asdf
 # nvm: 新しいシェルを開くだけ
 ```
 
-条件が一つあります。**Claude Code が tmux の中で動いていること。** 素のターミナルで起動したセッションには別プロセスから入力を送る手段がなく、どんなツールでも手が出せません。→ [tmux で Claude Code を動かす](#tmux-で-claude-code-を動かす)
+条件が一つあります。**Claude Code を tmux の中で動かすこと**です。素のターミナルで起動したセッションには、外のプロセスから入力を送る手段がありません。届く経路がない以上、どんなツールでも手が出せません。→ [tmux で Claude Code を動かす](#tmux-で-claude-code-を動かす)
 
-> 机に戻る手間が省けたなら、⭐ が同じ問題を抱えている人に届く助けになります。
+> 机に戻る手間が省けたなら、⭐ を付けてもらえると同じ問題を抱えている人に届きやすくなります。
 
-## 作業中のセッションには打ち込みません
+## 作業中のセッションには手を出しません
 
-これが設計上の核心です。タイマーでターミナルに文字を打ち込むツールは、「いま安全か」を確実に判断できない限り危険物でしかありません。以下はすべて実装され、[テスト](test/)されています。
+ここがこのツールの設計上いちばん難しいところです。タイマーでターミナルに文字を打ち込むツールは、「いま打っても安全か」を確実に判断できない限り、ただ危険なだけになります。以下はすべて実装済みで、[テスト](test/)で守られています。
 
-- **ターン実行中は絶対に打たない。** ペインを2秒あけて2回キャプチャします。実行中はスピナーとトークンカウンタが動くので、2回が一致すれば何も起きていない証拠、違えば手を出さない
-- **ダイアログには打たない。** 権限プロンプトや選択メニューでは Enter が「選択」になります。選択マーカーが画面にあれば、その回はスキップ
-- **あなたが開いたパネルには打たない。** `/remote-control` は QR コード付きのステータスパネルを開きます。cckeep が Enter を押すのは、自分で開いたときだけ
-- **自分で切ったセッションは戻さない。** 一度でも接続済みだったペインだけを追跡します。意図的に切ったものは切れたまま
-- **連打しない。** 1ペインにつき5分に1回まで
-- **直前に再確認する。** 判断は1回のキャプチャで下し、待機後にもう一度確認します。その間に復帰したりダイアログが出ていれば、何も送りません
+- **ターンの実行中は打たない。** ペインを2秒あけて2回キャプチャします。実行中はスピナーとトークン数が動くので、2回が同じなら何もしていない証拠です。違っていれば手を出しません
+- **ダイアログには打たない。** 権限プロンプトや選択メニューでは、Enter が「選択」になってしまいます。選択マーカーが画面にあれば、その回はまるごと見送ります
+- **自分で開いたパネルには触らない。** `/remote-control` は QR コード付きのステータスパネルを開きます。cckeep が Enter を押すのは、自分でパネルを開いたときだけです
+- **自分で切った接続は戻さない。** 一度でも接続できていたペインだけを対象にします。意図して切ったものは切れたままです
+- **連打しない。** 同じペインに手を出すのは5分に1回までです
+- **送る直前にもう一度確かめる。** 判断は1回のキャプチャで下しますが、待機したあとにもう一度確認します。その間に復帰していたり、ダイアログが出ていれば何も送りません
 
-`--dry-run` を付けると、何をするつもりかだけを表示して一切送信しません。
+`--dry-run` を付けると、送る内容を表示するだけで実際には何も送りません。
 
-## 何を見ているか
+## 何を見て判断しているか
 
 | 画面の状態 | 意味 | cckeep の動作 |
 |---|---|---|
-| `/rc active` | 接続中 | ペインを記憶するだけ |
-| `/rc reconnecting` | 31秒の予算内 | 待つ(たいていこれで直る) |
-| `/rc reconnecting` が2分継続 | 固着([#34255](https://github.com/anthropics/claude-code/issues/34255)) | パネルを開いて切断し、張り直す |
-| `Remote Control disconnected` | 諦めた | 即座に繋ぎ直す |
-| 表示なし(以前はあった) | 通知が流れて消えた | 4回静かなら繋ぎ直す |
-| 表示なし(一度もなかった) | そういう使い方ではない | 何もしない |
+| `/rc active` | 接続できている | ペインを覚えるだけ |
+| `/rc reconnecting` | 31秒の再試行中 | 待つ(たいていはこれで戻る) |
+| `/rc reconnecting` が2分以上 | 固まっている([#34255](https://github.com/anthropics/claude-code/issues/34255)) | パネルを開いて切断し、繋ぎ直す |
+| `Remote Control disconnected` | 諦めた | すぐに繋ぎ直す |
+| 表示なし(以前は出ていた) | 通知が流れて消えた | 4回続けて静かなら繋ぎ直す |
+| 表示なし(一度も出ていない) | そもそも使っていない | 何もしない |
 
 ## コマンド
 
@@ -85,17 +85,19 @@ asdf reshim nodejs # asdf
 cckeep                 # 状態表示: Claude Code のペインごとに1行
 cckeep watch           # スケジュール登録せずフォアグラウンドで実行
 cckeep once            # 1回だけ実行(スケジューラが叩くもの)
-cckeep install         # バックグラウンドジョブを登録
-cckeep uninstall       # 解除
+cckeep enable          # バックグラウンドでの監視を開始
+cckeep disable         # 監視を停止
 cckeep doctor          # tmux・ペイン・スケジューラ・各パス
 cckeep logs            # これまでの動作
 ```
 
 オプション: `--dry-run`、`--json`、`--interval <秒>`、`--lang en|ja`(`LANG` から自動判定)。
 
+`install` / `uninstall` は `enable` / `disable` のエイリアスとして引き続き使えます。
+
 ## tmux で Claude Code を動かす
 
-cckeep は tmux ペインを読み、そこに入力します。動いている Claude Code セッションに別プロセスから届く経路はこれだけで、だからこそ tmux 内での起動が必要です。プロセスの再起動は代替になりません — 会話が終わってしまい、守りたかったものそのものを失うからです。
+cckeep は tmux のペインを読み、そこに入力します。動いている Claude Code セッションに外のプロセスから届く経路はこれしかなく、だからこそ tmux の中で起動しておく必要があります。プロセスを再起動すればいい、という話でもありません。それでは会話そのものが終わってしまい、守りたかったものを自分で失うことになります。
 
 最小の変更は、対話起動だけを包むシェル関数です。`claude update` や `claude doctor`、`claude -p` はそのまま素通しします。
 
@@ -135,9 +137,9 @@ cc() {
 }
 ```
 
-`cc -c` と `cc --continue` はそのまま使えます — フラグは Claude Code にそのまま渡ります。上のブロックが埋めるのは、フラグでは救えないケース(tmux セッションだけ残って中の Claude Code が終了している状態)です。
+`cc -c` や `cc --continue` はそのまま使えます。フラグは Claude Code にそのまま渡ります。上のブロックが埋めているのは、フラグでは救えないケース、つまり tmux セッションだけが残って中の Claude Code が終了している状態です。
 
-あわせて `~/.tmux.conf` に2行必要です。これが無いと tmux 内で Shift+Enter とデスクトップ通知が壊れます([公式の案内](https://code.claude.com/docs/en/terminal-config#configure-tmux))。
+あわせて `~/.tmux.conf` に次の設定が必要です。これが無いと、tmux の中で Shift+Enter とデスクトップ通知が動かなくなります([公式の案内](https://code.claude.com/docs/en/terminal-config#configure-tmux))。
 
 ```sh
 set -g allow-passthrough on
@@ -145,11 +147,11 @@ set -s extended-keys on
 set -as terminal-features 'xterm*:extkeys'
 ```
 
-Ctrl+B の衝突は対処不要です。Claude Code は tmux を検出して、自身のショートカットを `Ctrl+B Ctrl+B` に読み替えます。
+Ctrl+B の衝突については何もしなくて構いません。Claude Code が tmux を検出して、自分のショートカットを `Ctrl+B Ctrl+B` に読み替えてくれます。
 
 ## 設定
 
-デフォルトは「存在に気づかない」ことを狙って調整してあります。`~/.cckeep/config.json`、環境変数、実行時フラグの順で上書きされます。壊れた設定ファイルは黙って一部だけ読むのではなく、エラーで停止します。
+デフォルト値は、動いていることに気づかない程度を狙って調整してあります。設定は `~/.cckeep/config.json`、環境変数、実行時フラグの順に上書きされます。設定ファイルが壊れている場合は、黙って一部だけ読み込むのではなくエラーで停止します。
 
 ```json
 {
@@ -162,52 +164,56 @@ Ctrl+B の衝突は対処不要です。Claude Code は tmux を検出して、
 }
 ```
 
-- `interval` — 巡回間隔(秒)。`install` が登録する間隔でもある
-- `cooldown` — 同じペインに再度手を出せるまでの秒数
-- `stuckLimit` — `reconnecting` が何回続いたら固着とみなすか
-- `missLimit` — 表示のあったペインが何回無表示なら繋ぎ直すか
-- `settle` — 静止判定の2回のキャプチャ間隔(ミリ秒)。遅いマシンでは増やす
-- `paneCommand` — Claude Code のペインと判定するフォアグラウンドプロセス名
+- `interval`: 巡回する間隔(秒)。`enable` が登録する間隔でもあります
+- `cooldown`: 同じペインに再び手を出せるようになるまでの秒数
+- `stuckLimit`: `reconnecting` の表示が何回続いたら固まったとみなすか
+- `missLimit`: 以前は表示があったペインが、何回続けて無表示なら繋ぎ直すか
+- `settle`: 静止判定に使う2回のキャプチャの間隔(ミリ秒)。遅いマシンでは増やしてください
+- `paneCommand`: Claude Code のペインだと判定するフォアグラウンドプロセス名
 
-すべてに環境変数版があります: `CCKEEP_INTERVAL`、`CCKEEP_COOLDOWN`、`CCKEEP_STUCK_LIMIT`、`CCKEEP_MISS_LIMIT`、`CCKEEP_SETTLE`、`CCKEEP_PANE_COMMAND`。`CCKEEP_HOME` で状態・設定・ログの置き場所を `~/.cckeep` から移せます。
+どの項目にも環境変数版があります。`CCKEEP_INTERVAL`、`CCKEEP_COOLDOWN`、`CCKEEP_STUCK_LIMIT`、`CCKEEP_MISS_LIMIT`、`CCKEEP_SETTLE`、`CCKEEP_PANE_COMMAND` です。`CCKEEP_HOME` を指定すれば、状態・設定・ログの置き場所を `~/.cckeep` 以外に移せます。
 
 ## 適用範囲
 
-cckeep がするのは接続の張り直しだけです。Claude Code の再試行予算そのものは**変えません** — クローズドソースのバイナリ内の定数であり、変えられるのは Anthropic だけです。[#34255](https://github.com/anthropics/claude-code/issues/34255) が修正されればこのツールは不要になります。それが正しい結末です。それまでは、ここに star を付けるより向こうに 👍 を付けるほうが価値があります。
+cckeep がするのは接続の張り直しだけです。Claude Code 側の再試行回数は**変えられません**。クローズドソースのバイナリに埋め込まれた定数なので、変えられるのは Anthropic だけです。[#34255](https://github.com/anthropics/claude-code/issues/34255) が修正されれば、このツールは要らなくなります。それがいちばん良い結末だと思っています。それまでは、ここに ⭐ を付けるより向こうに 👍 を付けるほうが役に立ちます。
 
 設計上、以下は対象外です。
 
-- **tmux 外のセッション** — 入力を送る経路がない
-- **VS Code 拡張** — ターミナル TUI ではなく、tmux で包めない
-- **サーバーモード**(`claude remote-control`)— 自分が起動したプロセスなので、launchd/systemd や `while true` ループで直接監督すればよい
-- **10分を超える通信断** — Claude Code 自身がセッションを終了するため、張り直す対象が残らない
+- **tmux の外のセッション**: 入力を送る経路がありません
+- **VS Code 拡張**: ターミナル TUI ではないので、tmux で包めません
+- **サーバーモード**(`claude remote-control`): 自分で起動したプロセスなので、launchd や systemd、あるいは `while true` ループで直接監督すれば済みます
+- **10分を超える通信断**: Claude Code 自身がセッションを終了してしまうため、張り直す相手が残りません
 
 ## プライバシー
 
-cckeep は接続状態を判定するために tmux ペインの表示テキストを読みます。それはあなたの会話です。したがって:
+cckeep は接続状態を判定するために、tmux ペインに表示されているテキストを読みます。それはあなたの会話そのものです。そのため、次のようにしています。
 
 - すべてローカルで完結し、このパッケージにネットワークコードはありません
 - テレメトリなし、アカウントなし、外部送信なし
-- ペインのテキストは数個の判定文字列と照合した後すぐ破棄され、ログに残るのはペイン名と判定結果だけです
-- ログは `~/.cckeep/cckeep.log`。`cckeep logs` で表示できます
+- ペインのテキストは数個の判定文字列と照合したあとすぐ破棄します。ログに残るのはペイン名と判定結果だけです
+- ログの場所は `~/.cckeep/cckeep.log` です。`cckeep logs` で表示できます
 
 ## 仕組み
 
-Claude Code はフッターにリモートコントロールの状態を描画します。接続中は `/rc active`、再試行中は `/rc reconnecting`、諦めたときは `Remote Control disconnected` の通知です。cckeep は tmux にフォアグラウンドプロセスが `claude` のペインを問い合わせ、`tmux capture-pane` からこれらを読み取り、ペインごとの小さなカウンタを `~/.cckeep/state.json` に保持します。
+Claude Code はフッターにリモートコントロールの状態を表示します。接続中は `/rc active`、再試行中は `/rc reconnecting`、諦めたときは `Remote Control disconnected` という通知です。cckeep は Claude Code が動いているペインを探し、`tmux capture-pane` の出力からこれらを読み取ります。ペインごとの小さなカウンタは `~/.cckeep/state.json` に保存します。
+
+ペインを探すところに一手間あります。Claude Code は自身のプロセスタイトルを書き換えるため、tmux はそのペインのコマンド名を `claude` ではなく `2.1.220` のように報告します。tmux の報告する名前だけで判定すると、実機では1つも見つかりません。そこで cckeep はプロセステーブルも参照し、ペインのプロセス(またはそこから起動されたプロセス)が実際に `claude` であればそのペインを対象とします。
+
+「どこを見るか」も同じくらい重要です。状態の判定に使う文字列は画面末尾の十数行からしか読みません。これらの言葉は普通の会話にも出てくるので、たとえば `/rc active` について話しているだけのセッションが「接続中」に見えてしまうからです。逆にダイアログとステータスパネルの検出は画面全体を対象にしています。こちらは誤検知しても1回見送るだけで済みますが、見落とすと誤ったキー入力に直結します。
 
-判定層(`src/detect.js`)は画面テキストと直前の状態だけを引数に取る純粋関数です。だからこそ安全ルールをターミナル無しで網羅的にテストできます。I/O は実行層(`src/run.js`)が担当します — 静止判定、直前の再確認、キー送信です。
+判定層(`src/detect.js`)は、画面テキストと直前の状態だけを受け取る純粋関数です。だからこそ、安全ルールをターミナル無しで網羅的にテストできます。静止判定・直前の再確認・キー送信といった I/O は、実行層(`src/run.js`)が担当します。
 
-これらは公開 API ではありません。判定文字列は UI テキストであり変わり得ます。変わったとき cckeep は誤動作ではなく沈黙します — 読めないペインは「一度も接続していない」ように見え、接続を見たことがないペインには決して手を出さないためです。
+これらは公開 API ではありません。判定に使っている文字列は UI のテキストなので、いつ変わってもおかしくありません。変わったとき cckeep は誤動作ではなく沈黙します。読めなくなったペインは「一度も接続していない」ように見え、接続を見たことがないペインには決して手を出さないからです。
 
 ## 開発
 
 ```sh
 git clone https://github.com/kamihork/cckeep.git && cd cckeep
-npm test                       # 36テスト。ネットワークも tmux も不要
+npm test                       # ネットワークも tmux も不要
 node bin/cckeep.js doctor
 ```
 
-テストは tmux をフェイクするのでどこでも走ります。コントリビューション歓迎です — 特に、検出が漏れる Claude Code のバージョンやターミナルでの実際の表示文字列が助かります。[CONTRIBUTING.md](CONTRIBUTING.md) を参照してください。
+テストは tmux をフェイクするので、どんな環境でも走ります。コントリビューションは歓迎です。特に、検出が漏れてしまう Claude Code のバージョンやターミナルでの実際の表示文字列を教えてもらえると助かります。詳しくは [CONTRIBUTING.md](CONTRIBUTING.md) を参照してください。
 
 ## ライセンス
 

package/README.md

@@ -29,12 +29,12 @@ Either way you find out the same way: you reach for your phone, and the session
 
 ```sh
 npm install -g cckeep
-cckeep install
+cckeep enable
 ```
 
-That registers a background job — launchd on macOS, a systemd user timer on Linux — that checks every 15 seconds and re-arms whatever went dead.
+`npm install` only puts the CLI on your `PATH`; `cckeep enable` is the step that registers a background job — launchd on macOS, a systemd user timer on Linux — that checks every 15 seconds and re-arms whatever went dead.
 
-Install it globally rather than running `npx cckeep install`. The scheduled job runs cckeep from wherever it was installed, and npx's cache is throwaway: a job pointing into it keeps working until the cache is cleared and then stops, silently — the one failure a watchdog must not have. `cckeep install` refuses to schedule from an npx path for that reason.
+Install it globally rather than running `npx cckeep enable`. The scheduled job runs cckeep from wherever it was installed, and npx's cache is throwaway: a job pointing into it keeps working until the cache is cleared and then stops, silently — the one failure a watchdog must not have. `cckeep enable` refuses to schedule from an npx path for that reason.
 
 To look before installing anything, `npx` is fine — neither of these changes a thing:
 
@@ -87,14 +87,16 @@ This is the whole design problem. A watchdog that types into your terminal on a
 cckeep                 # status: one line per Claude Code pane
 cckeep watch           # run in the foreground instead of scheduling
 cckeep once            # a single pass — what the scheduler runs
-cckeep install         # register the background job
-cckeep uninstall       # remove it
+cckeep enable          # start checking in the background
+cckeep disable         # stop checking
 cckeep doctor          # tmux, panes, scheduler, paths
 cckeep logs            # what it has done
 ```
 
 Options: `--dry-run`, `--json`, `--interval <s>`, `--lang en|ja` (auto-detected from `LANG`).
 
+`install` and `uninstall` still work as aliases for `enable` and `disable`.
+
 ## Running Claude Code in tmux
 
 cckeep reads and types into tmux panes. That is the only channel a separate process has into a live Claude Code session — and it is why the session must be started inside tmux. Restarting the process is not an alternative: it would end the conversation, which is exactly what you are trying to save.
@@ -166,7 +168,7 @@ Defaults are tuned so you never notice it. Override in `~/.cckeep/config.json`,
 }
 ```
 
-- `interval` — seconds between passes (also what `install` schedules)
+- `interval` — seconds between passes (also what `enable` schedules)
 - `cooldown` — seconds before the same pane may be acted on again
 - `stuckLimit` — checks in `reconnecting` before the bridge is treated as wedged
 - `missLimit` — checks with no indicator before re-arming a pane that had one
@@ -197,7 +199,11 @@ cckeep reads the visible text of your tmux panes to decide whether a pane is con
 
 ## How it works
 
-Claude Code paints a Remote Control indicator in its footer: `/rc active` when connected, `/rc reconnecting` while retrying, and a `Remote Control disconnected` notification when it gives up. cckeep asks tmux for every pane whose foreground process is `claude`, reads those indicators out of `tmux capture-pane`, and keeps a small per-pane counter in `~/.cckeep/state.json`.
+Claude Code paints a Remote Control indicator in its footer: `/rc active` when connected, `/rc reconnecting` while retrying, and a `Remote Control disconnected` notification when it gives up. cckeep finds the panes running Claude Code, reads those indicators out of `tmux capture-pane`, and keeps a small per-pane counter in `~/.cckeep/state.json`.
+
+Finding those panes takes one extra step: Claude Code rewrites its own process title, so tmux reports such a pane as `2.1.220` rather than `claude`. Matching the name tmux reports therefore finds nothing on a real machine. cckeep checks the process table as well, and treats a pane as Claude Code's when the pane's process — or anything it spawned — is actually `claude`.
+
+Where it looks matters as much as what it looks for. The state indicators are read from the last dozen lines only, because the words themselves turn up in ordinary conversation — a session where you happen to discuss `/rc active` would otherwise read as connected. Dialog and status-panel detection deliberately scans the whole pane instead: a false positive there costs one skipped pass, while a miss costs a keystroke in the wrong place.
 
 The decision layer (`src/detect.js`) is a pure function of screen text plus prior state, which is why the safety rules can be tested exhaustively without a terminal. The runner (`src/run.js`) does the I/O: the idle check, the last-moment re-check, and the keystrokes.
 

package/bin/cckeep.js

@@ -7,6 +7,8 @@ import { logPath, statePath, homeDir } from '../src/state.js';
 import * as tmux from '../src/tmux.js';
 import * as scheduler from '../src/scheduler.js';
 import { pickLang, strings } from '../src/i18n.js';
+import { resolveCommand } from '../src/commands.js';
+import { parsePsTable, isTargetPane } from '../src/procs.js';
 
 const HELP = `cckeep — keep Claude Code Remote Control from silently going dead
 
@@ -17,11 +19,14 @@ COMMANDS
   status          what cckeep sees right now (default)
   watch           run in the foreground, one pass every --interval seconds
   once            a single pass — what the scheduler runs
-  install         register a background job (launchd on macOS, systemd on Linux)
-  uninstall       remove it
+  enable          start checking in the background (launchd / systemd user timer)
+  disable         stop checking
   doctor          check tmux, Claude Code panes, and the scheduler
   logs            show recent actions
 
+  "npm install -g cckeep" only puts this CLI on your PATH. "cckeep enable" is
+  what registers the background job. (install / uninstall still work as aliases.)
+
 OPTIONS
   --interval <s>  seconds between passes (default 15)
   --dry-run       report what would be sent, send nothing
@@ -86,8 +91,10 @@ function render(out, t, opts) {
     console.log(t.hintOutside);
     return;
   }
+  // Session names carry a path hash, so they easily outrun a fixed column.
+  const width = Math.max(...out.results.map((r) => r.pane.length)) + 2;
   for (const r of out.results) {
-    console.log(`${r.pane.padEnd(14)}${describe(r, t)}`);
+    console.log(`${r.pane.padEnd(width)}${describe(r, t)}`);
   }
 }
 
@@ -107,7 +114,7 @@ async function main() {
     process.exit(1);
   }
 
-  switch (opts.command ?? 'status') {
+  switch (resolveCommand(opts.command)) {
     case 'status': {
       const out = await runPass({ config, dryRun: true });
       render(out, t, opts);
@@ -128,7 +135,7 @@ async function main() {
         await new Promise((r) => setTimeout(r, config.interval * 1000));
       }
     }
-    case 'install': {
+    case 'enable': {
       const res = scheduler.install({ interval: config.interval });
       if (res.kind === 'ephemeral') {
         console.error(t.ephemeral(res.path));
@@ -138,20 +145,21 @@ async function main() {
         console.log(t.unsupported);
         process.exit(1);
       }
-      console.log(res.ok ? t.installed(res.kind, res.path) : t.installFailed(res.kind));
+      console.log(res.ok ? t.enabled(res.kind, res.path) : t.enableFailed(res.kind));
       if (!res.ok) process.exit(1);
       break;
     }
-    case 'uninstall': {
+    case 'disable': {
       const res = scheduler.uninstall();
       if (res.kind === 'unsupported') return console.log(t.unsupported);
-      console.log(t.uninstalled(res.kind));
+      console.log(t.disabled(res.kind));
       break;
     }
     case 'doctor': {
       const bin = tmux.tmuxPath();
       const panes = bin && tmux.hasServer() ? tmux.listPanes() : [];
-      const claudePanes = panes.filter((p) => p.command === config.paneCommand);
+      const procs = parsePsTable(tmux.processTable());
+      const claudePanes = panes.filter((p) => isTargetPane(p, procs, config.paneCommand));
       const rows = [
         ['platform', platform()],
         ['node', process.version],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cckeep",
-  "version": "0.1.2",
+  "version": "0.2.3",
   "description": "Keeps Claude Code Remote Control from silently going dead. Re-arms the sessions its 31-second retry budget gives up on — local, tmux-native, zero dependencies.",
   "type": "module",
   "bin": {

package/src/commands.js

@@ -0,0 +1,35 @@
+/**
+ * `npm install -g cckeep` puts the CLI on your PATH; registering the background
+ * job is a separate, deliberate step. Naming that step `install` too made the
+ * quick start read as if you were installing twice, so the scheduler verbs are
+ * `enable` / `disable` — the same words systemctl uses for the same idea.
+ *
+ * The old names stay as aliases: they shipped in 0.1.x and in the plists people
+ * already generated, and breaking them buys nothing.
+ */
+export const ALIASES = {
+  install: 'enable',
+  uninstall: 'disable',
+};
+
+export const COMMANDS = new Set([
+  'status',
+  'watch',
+  'once',
+  'enable',
+  'disable',
+  'doctor',
+  'logs',
+  'help',
+  'version',
+]);
+
+/** Map whatever the user typed onto a canonical command. */
+export function resolveCommand(input) {
+  const name = input ?? 'status';
+  return ALIASES[name] ?? name;
+}
+
+export function isKnownCommand(input) {
+  return COMMANDS.has(resolveCommand(input));
+}

package/src/config.js

@@ -5,7 +5,7 @@ import { DEFAULTS } from './detect.js';
 
 export const BASE = {
   ...DEFAULTS,
-  /** Seconds between passes in watch mode, and what `install` schedules. */
+  /** Seconds between passes in watch mode, and what `enable` schedules. */
   interval: 15,
   /** Milliseconds between the two captures of the idle check. */
   settle: 2000,

package/src/detect.js

@@ -17,6 +17,17 @@ const PANEL = /Disconnect this session|(?:Show|Hide) QR code/;
  */
 const MODAL = /(?:❯|›)\s*(?:\d+\.|Yes|No)|Do you want|\(y\/n\)/;
 
+/**
+ * How many lines from the bottom count as "the footer".
+ *
+ * The indicators live just below the input box, but the words themselves can
+ * appear anywhere in a transcript — a session where you discuss cckeep, or run
+ * it, will have "/rc active" sitting in the conversation body. Matching the
+ * whole pane made such a session look connected, which then armed the
+ * missing-indicator fallback and pointed it at a perfectly healthy session.
+ */
+const FOOTER_LINES = 12;
+
 export const DEFAULTS = {
   /** Consecutive checks stuck in "reconnecting" before we treat the bridge as wedged. */
   stuckLimit: 8,
@@ -34,11 +45,20 @@ export function emptyState() {
  * Reduce a captured pane to the handful of signals the rules care about.
  * @param {string} screen raw `tmux capture-pane -p` output
  */
-export function readScreen(screen) {
+export function readScreen(screen, footerLines = FOOTER_LINES) {
+  const lines = String(screen).split('\n');
+  const footer = lines.slice(Math.max(0, lines.length - footerLines)).join('\n');
+
   return {
-    connected: screen.includes(CONNECTED),
-    retrying: screen.includes(RETRYING),
-    failed: FAILED.test(screen),
+    // Signals that make cckeep act are read from the footer only, so text in
+    // the conversation cannot trigger anything.
+    connected: footer.includes(CONNECTED),
+    retrying: footer.includes(RETRYING),
+    failed: FAILED.test(footer),
+
+    // Signals that make cckeep hold off are read from the whole pane. A false
+    // positive here costs a skipped pass; missing one costs a keystroke in the
+    // wrong place.
     panel: PANEL.test(screen),
     modal: MODAL.test(screen),
   };

package/src/i18n.js

@@ -7,7 +7,7 @@ const en = {
   connected: 'connected',
   retrying: 'retrying',
   waiting: 'no indicator',
-  neverConnected: 'not connected',
+  neverConnected: 'no indicator seen yet',
   dialog: 'dialog open',
   cooldown: 'cooling down',
   busy: 'busy',
@@ -17,11 +17,11 @@ const en = {
   wouldRearm: 'would re-arm',
   wouldConfirm: 'would cycle bridge',
   watching: (n) => `Watching every ${n}s. Ctrl+C to stop.`,
-  installed: (kind, path) => `Installed (${kind}): ${path}`,
-  installFailed: (kind) => `Wrote the ${kind} unit, but could not load it. Load it manually, or run \`cckeep watch\` in a terminal.`,
-  uninstalled: (kind) => `Removed the ${kind} job.`,
+  enabled: (kind, path) => `Enabled (${kind}): ${path}`,
+  enableFailed: (kind) => `Wrote the ${kind} unit, but could not load it. Load it manually, or run \`cckeep watch\` in a terminal.`,
+  disabled: (kind) => `Disabled — removed the ${kind} job.`,
   unsupported: 'Automatic scheduling supports macOS (launchd) and Linux (systemd user timers). Elsewhere, run `cckeep watch` under your own supervisor.',
-  ephemeral: (p) => `Refusing to schedule: this copy of cckeep lives in npm's throwaway npx cache\n  ${p}\nA scheduled job pointing there stops working the moment the cache is cleared — silently. Install it properly first:\n\n  npm install -g cckeep && cckeep install\n`,
+  ephemeral: (p) => `Refusing to schedule: this copy of cckeep lives in npm's throwaway npx cache\n  ${p}\nA scheduled job pointing there stops working the moment the cache is cleared — silently. Install it properly first:\n\n  npm install -g cckeep && cckeep enable\n`,
   scheduledPath: 'scheduled cmd',
   scheduledMissing: 'MISSING — run `cckeep install` again',
   noLog: 'No log yet.',
@@ -30,34 +30,34 @@ const en = {
 };
 
 const ja = {
-  noTmux: 'tmux が見つかりません。cckeep は tmux のペインを読んで入力するため、tmux が必須です。',
-  noServer: 'tmux サーバーが起動していません。監視対象がありません。',
-  noPanes: 'Claude Code が動いている tmux ペインがありません。',
-  hintOutside: 'tmux の外で起動した Claude Code には届きません。別プロセスから入力を送る手段がないためです。',
+  noTmux: 'tmux が見つかりません。cckeep は tmux のペインを読んで入力するので、tmux が必要です。',
+  noServer: 'tmux が起動していないので、監視するものがありません。',
+  noPanes: 'Claude Code が動いている tmux ペインが見つかりません。',
+  hintOutside: 'tmux の外で起動した Claude Code には手が出せません。外のプロセスから入力を送る経路がないためです。',
   header: 'ペイン        状態           詳細',
   connected: '接続中',
   retrying: '再試行中',
   waiting: '表示なし',
-  neverConnected: '未接続',
-  dialog: 'ダイアログ表示中',
-  cooldown: 'クールダウン中',
-  busy: '実行中',
-  recovered: '復帰済み',
-  rearmed: '再接続を送信',
-  confirmed: 'ブリッジを張り直し',
-  wouldRearm: '再接続を送信する',
-  wouldConfirm: 'ブリッジを張り直す',
-  watching: (n) => `${n} 秒ごとに監視します。Ctrl+C で停止。`,
-  installed: (kind, path) => `登録しました (${kind}): ${path}`,
-  installFailed: (kind) => `${kind} の定義は書きましたが、読み込みに失敗しました。手動で読み込むか、ターミナルで \`cckeep watch\` を実行してください。`,
-  uninstalled: (kind) => `${kind} のジョブを削除しました。`,
-  unsupported: '自動スケジュール登録は macOS (launchd) と Linux (systemd user timer) に対応しています。それ以外では `cckeep watch` を任意の常駐手段で動かしてください。',
-  ephemeral: (p) => `登録を中止しました: この cckeep は npm の使い捨て npx キャッシュ内にあります\n  ${p}\nここを指すジョブは、キャッシュが消された瞬間に黙って動かなくなります。先に正式にインストールしてください:\n\n  npm install -g cckeep && cckeep install\n`,
+  neverConnected: '接続表示は未確認',
+  dialog: 'ダイアログが開いている',
+  cooldown: '待機中(連打防止)',
+  busy: '実行中のためスキップ',
+  recovered: '自力で復帰',
+  rearmed: '繋ぎ直しました',
+  confirmed: '接続を張り直しました',
+  wouldRearm: '繋ぎ直します',
+  wouldConfirm: '接続を張り直します',
+  watching: (n) => `${n} 秒ごとに確認します。止めるときは Ctrl+C。`,
+  enabled: (kind, path) => `有効にしました(${kind})。定義ファイル: ${path}`,
+  enableFailed: (kind) => `${kind} の定義ファイルは作成しましたが、読み込みに失敗しました。手動で読み込むか、ターミナルで \`cckeep watch\` を動かしてください。`,
+  disabled: (kind) => `無効にしました。${kind} のジョブを削除しています。`,
+  unsupported: '自動登録に対応しているのは macOS(launchd)と Linux(systemd user timer)です。それ以外の環境では、`cckeep watch` をお使いの常駐手段で動かしてください。',
+  ephemeral: (p) => `登録を中止しました。この cckeep は npm の使い捨てキャッシュ(npx)の中にあります。\n  ${p}\nここを指すジョブは、キャッシュが消えた瞬間に何も言わず動かなくなります。先にグローバルへインストールしてください。\n\n  npm install -g cckeep && cckeep enable\n`,
   scheduledPath: '登録先',
-  scheduledMissing: '見つかりません — `cckeep install` を再実行してください',
-  noLog: 'ログはまだありません。',
+  scheduledMissing: '見つかりません(`cckeep enable` を実行し直してください)',
+  noLog: 'まだログはありません。',
   doctorOk: 'ok',
-  doctorFail: '未検出',
+  doctorFail: '見つかりません',
 };
 
 export function pickLang(explicit) {

package/src/procs.js

@@ -0,0 +1,64 @@
+/**
+ * Claude Code rewrites its own process title, so tmux reports a pane running it
+ * as e.g. "2.1.220" rather than "claude". Matching `pane_current_command`
+ * against a name therefore finds nothing on a real machine — which is exactly
+ * the bug this module exists to fix.
+ *
+ * The executable name is still correct in the process table, so that is what we
+ * check. Pure functions here; the one `ps` call lives in tmux.js.
+ */
+
+/** Parse `ps -Ao pid=,ppid=,comm=` into a pid -> {ppid, comm} map. */
+export function parsePsTable(output) {
+  const table = new Map();
+  for (const line of String(output).split('\n')) {
+    const m = line.trim().match(/^(\d+)\s+(\d+)\s+(.*)$/);
+    if (!m) continue;
+    const [, pid, ppid, rawComm] = m;
+    // macOS prints the full path here for some processes; Linux prints a name.
+    const comm = rawComm.trim().split('/').pop();
+    table.set(Number(pid), { ppid: Number(ppid), comm });
+  }
+  return table;
+}
+
+/**
+ * Does `rootPid` — or anything it spawned — run `name`?
+ *
+ * A pane usually runs Claude Code directly, but someone may have it under a
+ * shell, a wrapper, or a version manager's shim, so descendants count too.
+ */
+export function hasDescendantNamed(table, rootPid, name, maxDepth = 4) {
+  if (!table || !rootPid) return false;
+
+  const children = new Map();
+  for (const [pid, info] of table) {
+    if (!children.has(info.ppid)) children.set(info.ppid, []);
+    children.get(info.ppid).push(pid);
+  }
+
+  const seen = new Set();
+  let frontier = [Number(rootPid)];
+  for (let depth = 0; depth <= maxDepth && frontier.length; depth++) {
+    const next = [];
+    for (const pid of frontier) {
+      if (seen.has(pid)) continue;
+      seen.add(pid);
+      if (table.get(pid)?.comm === name) return true;
+      next.push(...(children.get(pid) ?? []));
+    }
+    frontier = next;
+  }
+  return false;
+}
+
+/**
+ * Is this pane running Claude Code?
+ *
+ * The name tmux reports is the fast path and still works wherever the title is
+ * left alone; the process table is the fallback that makes it work at all.
+ */
+export function isTargetPane(pane, table, name) {
+  if (pane.command === name) return true;
+  return hasDescendantNamed(table, pane.pid, name);
+}

package/src/run.js

@@ -1,4 +1,5 @@
 import { decide, readScreen } from './detect.js';
+import { parsePsTable, isTargetPane } from './procs.js';
 import * as realTmux from './tmux.js';
 import { loadState, saveState, forPane, prune, appendLog } from './state.js';
 
@@ -31,11 +32,12 @@ export async function runPass({ tmux = realTmux, config, dryRun = false, now = M
   if (!tmux.hasServer()) return { results, acted: 0, error: 'no-server' };
 
   const panes = tmux.listPanes();
+  const procs = parsePsTable(tmux.processTable ? tmux.processTable() : '');
   const state = loadState();
   let acted = 0;
 
   for (const pane of panes) {
-    if (pane.command !== config.paneCommand) continue;
+    if (!isTargetPane(pane, procs, config.paneCommand)) continue;
 
     const screen = tmux.capture(pane.id);
     if (!screen) continue;

package/src/tmux.js

@@ -44,17 +44,41 @@ export function hasServer() {
 
 /** Every pane on the server, with the process currently in the foreground. */
 export function listPanes() {
-  const out = tmux(['list-panes', '-a', '-F', '#{pane_id}\t#{pane_current_command}\t#{session_name}\t#{window_index}\t#{pane_index}']);
+  const out = tmux(['list-panes', '-a', '-F', '#{pane_id}\t#{pane_current_command}\t#{session_name}\t#{window_index}\t#{pane_index}\t#{pane_pid}']);
   if (!out) return [];
   return out
     .split('\n')
     .filter(Boolean)
     .map((line) => {
-      const [id, command, session, windowIndex, paneIndex] = line.split('\t');
-      return { id, command, session, windowIndex, paneIndex, label: `${session}:${windowIndex}.${paneIndex}` };
+      const [id, command, session, windowIndex, paneIndex, pid] = line.split('\t');
+      return {
+        id,
+        command,
+        session,
+        windowIndex,
+        paneIndex,
+        pid: Number(pid),
+        label: `${session}:${windowIndex}.${paneIndex}`,
+      };
     });
 }
 
+/**
+ * One snapshot of the process table per pass. Claude Code rewrites its process
+ * title, so the name tmux reports is not enough to recognise a pane running it.
+ */
+export function processTable() {
+  try {
+    return execFileSync('ps', ['-Ao', 'pid=,ppid=,comm='], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      maxBuffer: 8 * 1024 * 1024,
+    });
+  } catch {
+    return '';
+  }
+}
+
 export function capture(paneId) {
   return tmux(['capture-pane', '-p', '-t', paneId]) ?? '';
 }