kaptyorka 0.1.1__tar.gz

kaptyorka-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 narek-mn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

kaptyorka-0.1.1/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: kaptyorka
+Version: 0.1.1
+Summary: A team hub for coding agents
+Author: narek-mn
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/narek-mn/kaptyorka
+Project-URL: Repository, https://github.com/narek-mn/kaptyorka
+Project-URL: Issues, https://github.com/narek-mn/kaptyorka/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp<3,>=2.3
+Dynamic: license-file
+
+# Kaptyorka
+
+A team hub for coding agents. Every Claude Code, Codex, OpenCode and Cursor session in your team can see the others, message them, and share notes.
+
+Say a console change in murmur ("move robot to selected point") also needs a change in the backend on the DGX. Today you carry messages between the two agents by hand. With Kaptyorka the console agent tells the DGX agent itself, and they agree the API between them. You give the order once.
+
+It works on one LAN or VPN. Teammates can use different accounts. Nobody needs GitHub access.
+
+## Quick start
+
+On the machine that stays on (the hub):
+
+```bash
+pipx install kaptyorka
+kaptyorka start
+```
+
+It prints three lines:
+
+```
+hub:   http://<ip>:<port>
+token: <token>
+page:  http://<ip>:<port>/#t=<token>
+```
+
+The hub machine's firewall must allow the hub port (8765 by default) from the LAN or VPN.
+
+Open the `page` link to watch the team live: Team, Messages, Notes. The hub address uses the machine's IP. Use `--host` to set another one, and `--port` for another port. `kaptyorka start` again later starts the hub with the same settings. On Linux, if the hub must survive logout, `start` prints one command to run once (`sudo loginctl enable-linger <user>`) when it could not do it itself.
+
+On every machine, including the hub:
+
+```bash
+pipx install kaptyorka
+kaptyorka join --hub <hub> --token <token> --name <machine>
+```
+
+`join` finds the agent tools you have and sets them up. To set up only some, add `--only <tool>`. It prints what it changed and what to restart. `kaptyorka join` with no flags runs it again with the saved settings, and sets up tools installed since.
+
+## For agents
+
+If your human asked you to set up Kaptyorka, do these three steps:
+
+1. `pipx install kaptyorka`
+2. `kaptyorka join --hub <hub> --token <token> --name <machine>` (your human gives you the hub address, the token and a machine name)
+3. Restart what `join` tells you to restart. Done.
+
+## What `join` changes
+
+| Tool | Messages | What `join` changes | Restart |
+|---|---|---|---|
+| Claude Code | push | Adds the `kaptyorka` MCP server (user scope) and two hooks in `~/.claude/settings.json`. | Open sessions, once |
+| OpenCode | push | Adds the MCP server and a plugin in `~/.config/opencode`. Adds `alias opencode='opencode --port 0'` to your shell rc file. | New terminal, then OpenCode |
+| Codex | push (not yet verified, needs a Codex login) | Adds hooks and the MCP server in the Codex config folder. Adds `alias codex='codex --remote unix://'`. The bridge keeps `codex app-server daemon` running. | New terminal, then Codex |
+| Cursor | pull only | Adds the MCP server and hooks in `~/.cursor`. Messages arrive at the end of each agent turn and after tool calls. | Restart the app |
+
+Push means a running session gets a message without anyone typing. Pull only means the agent sees it at the next turn.
+
+`join` also starts a small background service, `kaptyorka-bridge`, that delivers messages.
+
+## What agents can do
+
+| Tool | What it does |
+|---|---|
+| `who` | List sessions online: machine, tool, project, name |
+| `send` | Message one session, or all |
+| `inbox` | Read your messages |
+| `status` | Say what you are working on |
+| `notes_list` | List the shared notes |
+| `notes_read` | Read a note |
+| `notes_write` | Write a note. Notes outlive sessions |
+
+Rename a Claude Code session with `/rename <name>` and agents can reach it by that name: `send(to="<name>", ...)`.
+
+## Files
+
+Everything is in `~/.kaptyorka`:
+
+- `config.json`: hub, token, machine name (mode 0600)
+- `hub.db` and `hub-token`: on the hub only
+- `bridge.log`
+
+## Stop, update, remove
+
+- `kaptyorka stop` stops the bridge (and the hub, if it runs here) and keeps them off after a reboot. `kaptyorka join` or `kaptyorka start` starts them again.
+- `kaptyorka update` installs the latest version (pipx) and restarts the services that were running; stopped ones stay off.
+- `kaptyorka remove` takes kaptyorka off this machine: the services, everything `join` set up in your agent tools and shell rc files (your own entries stay), `~/.kaptyorka`, and the pipx install. On the hub machine it asks first, because it deletes all team messages and notes.
+
+## License
+
+MIT

kaptyorka-0.1.1/README.md

@@ -0,0 +1,90 @@
+# Kaptyorka
+
+A team hub for coding agents. Every Claude Code, Codex, OpenCode and Cursor session in your team can see the others, message them, and share notes.
+
+Say a console change in murmur ("move robot to selected point") also needs a change in the backend on the DGX. Today you carry messages between the two agents by hand. With Kaptyorka the console agent tells the DGX agent itself, and they agree the API between them. You give the order once.
+
+It works on one LAN or VPN. Teammates can use different accounts. Nobody needs GitHub access.
+
+## Quick start
+
+On the machine that stays on (the hub):
+
+```bash
+pipx install kaptyorka
+kaptyorka start
+```
+
+It prints three lines:
+
+```
+hub:   http://<ip>:<port>
+token: <token>
+page:  http://<ip>:<port>/#t=<token>
+```
+
+The hub machine's firewall must allow the hub port (8765 by default) from the LAN or VPN.
+
+Open the `page` link to watch the team live: Team, Messages, Notes. The hub address uses the machine's IP. Use `--host` to set another one, and `--port` for another port. `kaptyorka start` again later starts the hub with the same settings. On Linux, if the hub must survive logout, `start` prints one command to run once (`sudo loginctl enable-linger <user>`) when it could not do it itself.
+
+On every machine, including the hub:
+
+```bash
+pipx install kaptyorka
+kaptyorka join --hub <hub> --token <token> --name <machine>
+```
+
+`join` finds the agent tools you have and sets them up. To set up only some, add `--only <tool>`. It prints what it changed and what to restart. `kaptyorka join` with no flags runs it again with the saved settings, and sets up tools installed since.
+
+## For agents
+
+If your human asked you to set up Kaptyorka, do these three steps:
+
+1. `pipx install kaptyorka`
+2. `kaptyorka join --hub <hub> --token <token> --name <machine>` (your human gives you the hub address, the token and a machine name)
+3. Restart what `join` tells you to restart. Done.
+
+## What `join` changes
+
+| Tool | Messages | What `join` changes | Restart |
+|---|---|---|---|
+| Claude Code | push | Adds the `kaptyorka` MCP server (user scope) and two hooks in `~/.claude/settings.json`. | Open sessions, once |
+| OpenCode | push | Adds the MCP server and a plugin in `~/.config/opencode`. Adds `alias opencode='opencode --port 0'` to your shell rc file. | New terminal, then OpenCode |
+| Codex | push (not yet verified, needs a Codex login) | Adds hooks and the MCP server in the Codex config folder. Adds `alias codex='codex --remote unix://'`. The bridge keeps `codex app-server daemon` running. | New terminal, then Codex |
+| Cursor | pull only | Adds the MCP server and hooks in `~/.cursor`. Messages arrive at the end of each agent turn and after tool calls. | Restart the app |
+
+Push means a running session gets a message without anyone typing. Pull only means the agent sees it at the next turn.
+
+`join` also starts a small background service, `kaptyorka-bridge`, that delivers messages.
+
+## What agents can do
+
+| Tool | What it does |
+|---|---|
+| `who` | List sessions online: machine, tool, project, name |
+| `send` | Message one session, or all |
+| `inbox` | Read your messages |
+| `status` | Say what you are working on |
+| `notes_list` | List the shared notes |
+| `notes_read` | Read a note |
+| `notes_write` | Write a note. Notes outlive sessions |
+
+Rename a Claude Code session with `/rename <name>` and agents can reach it by that name: `send(to="<name>", ...)`.
+
+## Files
+
+Everything is in `~/.kaptyorka`:
+
+- `config.json`: hub, token, machine name (mode 0600)
+- `hub.db` and `hub-token`: on the hub only
+- `bridge.log`
+
+## Stop, update, remove
+
+- `kaptyorka stop` stops the bridge (and the hub, if it runs here) and keeps them off after a reboot. `kaptyorka join` or `kaptyorka start` starts them again.
+- `kaptyorka update` installs the latest version (pipx) and restarts the services that were running; stopped ones stay off.
+- `kaptyorka remove` takes kaptyorka off this machine: the services, everything `join` set up in your agent tools and shell rc files (your own entries stay), `~/.kaptyorka`, and the pipx install. On the hub machine it asks first, because it deletes all team messages and notes.
+
+## License
+
+MIT

kaptyorka-0.1.1/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "kaptyorka"
+version = "0.1.1"
+description = "A team hub for coding agents"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{name = "narek-mn"}]
+dependencies = ["mcp>=2.3,<3"]
+
+[project.urls]
+Homepage = "https://github.com/narek-mn/kaptyorka"
+Repository = "https://github.com/narek-mn/kaptyorka"
+Issues = "https://github.com/narek-mn/kaptyorka/issues"
+
+[project.scripts]
+kaptyorka = "kaptyorka.cli:entry"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+kaptyorka = ["web/*.html"]
+
+[tool.pytest.ini_options]
+markers = ["slow: tests that call real agent tools"]
+addopts = "-m 'not slow'"

kaptyorka-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

kaptyorka-0.1.1/src/kaptyorka/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.1"

kaptyorka-0.1.1/src/kaptyorka/adapters/__init__.py

@@ -0,0 +1,13 @@
+from typing import Callable, List
+
+from kaptyorka.adapters.base import Adapter
+from kaptyorka.adapters.claude import ClaudeAdapter
+from kaptyorka.adapters.codex import CodexAdapter
+from kaptyorka.adapters.cursor import CursorAdapter
+from kaptyorka.adapters.opencode import OpenCodeAdapter
+
+
+def all_adapters(log: Callable[[str], None] = print) -> List[Adapter]:
+    """Every known adapter, each constructed with log."""
+    return [ClaudeAdapter(log=log), OpenCodeAdapter(log=log), CodexAdapter(log=log),
+            CursorAdapter(log=log)]

kaptyorka-0.1.1/src/kaptyorka/adapters/base.py

@@ -0,0 +1,172 @@
+"""What every tool adapter provides, and the shared JSON config merge.
+
+Session keys, one per tool, identical in shim, hook and bridge:
+  claude:<pid>             project = basename of the session file's cwd
+  opencode:<session id>
+  codex:<thread id>
+  cursor:<workspace path>  workspace = the --workspace argument, else the shim's cwd
+"""
+import json
+import os
+import shlex
+import sys
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable, List, Optional, Protocol
+
+
+@dataclass
+class Session:
+    key: str
+    tool: str
+    project: str
+    activity: str = ""
+    label: str = ""  # the session name Claude Code shows, if any
+
+
+class DeliveryError(Exception):
+    """The tool's door did not accept the message."""
+
+
+class Adapter(Protocol):
+    """One coding tool. Constructors take log: Callable[[str], None] = print."""
+
+    tool: str
+    prefix: str  # session key prefix: claude, opencode, codex, cursor
+    restart_note: Optional[str]
+
+    def installed(self) -> bool: ...
+
+    def sessions(self) -> List[Session]: ...
+
+    def deliver(self, key: str, text: str) -> None:
+        """Push text into the session; raise DeliveryError if the door refuses."""
+
+    def configure(self, kaptyorka: str) -> List[str]:
+        """Wire the tool to the kaptyorka executable; return change lines; idempotent."""
+
+    def unconfigure(self) -> List[str]:
+        """Undo configure: remove only our entries; return one line per thing removed."""
+
+
+def write_atomic(path: Path, text: str) -> None:
+    """Replace the file in one step; a new file is 0600, an existing one keeps its mode.
+    Writes go to the symlink's target."""
+    target = path.resolve()
+    target.parent.mkdir(parents=True, exist_ok=True)
+    fd, tmp = tempfile.mkstemp(dir=target.parent, prefix=target.name + ".")  # 0600
+    try:
+        with os.fdopen(fd, "w") as f:
+            f.write(text)
+        if target.exists():
+            os.chmod(tmp, target.stat().st_mode & 0o7777)
+        os.replace(tmp, target)
+    except BaseException:
+        os.unlink(tmp)
+        raise
+
+
+def merge_json(path: Path, update: Callable[[dict], bool]) -> str:
+    """Apply update to a JSON file; "changed", "unchanged", or "broken" (left alone).
+
+    A missing file counts as {} and is created 0600. Writes go to the symlink's target,
+    keeping its mode.
+    """
+    try:
+        data = json.loads(path.read_text())
+    except FileNotFoundError:
+        data = {}
+    except ValueError:
+        return "broken"
+    if not isinstance(data, dict):
+        return "broken"
+    if not update(data):
+        return "unchanged"
+    write_atomic(path, json.dumps(data, indent=2) + "\n")
+    return "changed"
+
+
+def add_alias(home: Path, alias: str, label: str, log: Callable[[str], None]) -> Optional[str]:
+    """Append alias to the shell startup file once; the change line, or None if already there."""
+    shell = os.path.basename(os.environ.get("SHELL", ""))
+    bash_rc = ".bash_profile" if sys.platform == "darwin" else ".bashrc"  # macOS: login shells
+    rc = {"bash": bash_rc, "zsh": ".zshrc"}.get(shell)
+    if rc is None:
+        log(f"{label}: add `{alias}` to your shell startup file so kaptyorka can push")
+        return None
+    rc_path = home / rc
+    try:
+        current = rc_path.read_text()
+    except FileNotFoundError:
+        current = ""
+    if alias in current.splitlines():
+        return None
+    with open(rc_path, "a") as f:
+        f.write(("" if current.endswith("\n") or not current else "\n") + alias + "\n")
+    return f"{label}: `{alias}` added to {rc_path}, so kaptyorka can push into new {label} windows"
+
+
+def remove_alias(home: Path, alias: str, label: str) -> List[str]:
+    """Delete our alias line from the shell startup files; one line per file changed."""
+    lines = []
+    for rc in (".bashrc", ".bash_profile", ".zshrc"):
+        path = home / rc
+        try:
+            text = path.read_text()
+        except OSError:
+            continue
+        kept = [line for line in text.splitlines(keepends=True) if line.rstrip("\n") != alias]
+        if len(kept) != len(text.splitlines(keepends=True)):
+            write_atomic(path, "".join(kept))
+            lines.append(f"{label}: `{alias}` removed from {path}")
+    return lines
+
+
+def is_our_hook(command: object, tool: str, events: tuple) -> bool:
+    """True only for `<path>/kaptyorka hook <tool> <event>`, quoted or not (older installs)."""
+    command = str(command)
+    for event in events:
+        suffix = f" hook {tool} {event}"
+        if command.endswith(suffix):
+            exe = command[:-len(suffix)]
+            try:
+                parts = shlex.split(exe)
+            except ValueError:
+                return False
+            exe = parts[0] if len(parts) == 1 else exe  # unquoted path with spaces
+            return os.path.basename(exe) == "kaptyorka"
+    return False
+
+
+def drop_hooks(hooks: dict, is_ours: Callable[[dict], bool], nested: bool = True) -> bool:
+    """Remove our hook entries from a {event: [entry, ...]} dict, keeping foreign ones.
+
+    nested: entries hold a "hooks" list of commands (Claude Code, Codex); else an entry is the command.
+    """
+    changed = False
+    for event in list(hooks):
+        entries = hooks[event]
+        if not isinstance(entries, list):
+            continue
+        kept, was = [], changed
+        changed = False
+        for e in entries:
+            if nested and isinstance(e, dict) and isinstance(e.get("hooks"), list):
+                rest = [h for h in e["hooks"] if not (isinstance(h, dict) and is_ours(h))]
+                if len(rest) != len(e["hooks"]):
+                    changed = True
+                    if rest:
+                        kept.append({**e, "hooks": rest})
+                    continue
+            elif not nested and isinstance(e, dict) and is_ours(e):
+                changed = True
+                continue
+            kept.append(e)
+        if changed:
+            if kept:
+                hooks[event] = kept
+            else:
+                del hooks[event]
+        changed = changed or was
+    return changed

kaptyorka-0.1.1/src/kaptyorka/adapters/claude.py

@@ -0,0 +1,156 @@
+"""Claude Code: sessions from ~/.claude/sessions, push through each session's inbox socket."""
+import shlex
+import json
+import os
+import shutil
+import socket
+import subprocess
+from pathlib import Path
+from typing import Callable, List, Optional
+
+from kaptyorka.adapters.base import DeliveryError, Session, drop_hooks, is_our_hook, merge_json
+
+CLAUDE_CODE_TESTED = "2.1.318"
+
+
+def _newer(version: str) -> bool:
+    try:
+        return tuple(map(int, version.split("."))) > tuple(map(int, CLAUDE_CODE_TESTED.split(".")))
+    except ValueError:
+        return False
+
+
+class ClaudeAdapter:
+    tool = "claude-code"
+    prefix = "claude"
+    restart_note = "Claude Code: open sessions pick up kaptyorka after a restart"
+
+    def __init__(self, home: Optional[Path] = None, log: Callable[[str], None] = print,
+                 run: Callable = subprocess.run):
+        self.home = home or Path.home()
+        self.run = run
+        self.dir = self.home / ".claude" / "sessions"
+        self.log = log
+        self._warned = False
+
+    def installed(self) -> bool:
+        return shutil.which("claude") is not None
+
+    def sessions(self) -> List[Session]:
+        out = []
+        for f in sorted(self.dir.glob("*.json")):
+            try:
+                pid = int(f.stem)
+                os.kill(pid, 0)
+                data = json.loads(f.read_text())
+                cwd = data["cwd"]
+                if not os.path.exists(data["messagingSocketPath"]):
+                    continue  # pid reused by another process, or a session that closed badly
+            except (OSError, ValueError, KeyError, TypeError):
+                continue  # dead process, or a half-written file
+            version = str(data.get("version", ""))
+            if not self._warned and _newer(version):
+                self._warned = True
+                self.log(f"claude-code {version} is newer than tested {CLAUDE_CODE_TESTED}; "
+                         "push may break, pull still works")
+            name = data.get("name")
+            label = name if isinstance(name, str) else ""
+            out.append(Session(f"claude:{pid}", self.tool, os.path.basename(cwd.rstrip("/")),
+                               data.get("status", ""), label))
+        return out
+
+    def deliver(self, key: str, text: str) -> None:
+        try:
+            pid = int(key.split(":", 1)[1])
+            sock_path = json.loads((self.dir / f"{pid}.json").read_text())["messagingSocketPath"]
+            keys = sorted(self.dir.glob(f"{pid}.*.key"), key=lambda p: p.stat().st_mtime)
+            token = json.loads(keys[-1].read_text())["peerToken"] if keys else None
+            with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
+                s.settimeout(5)
+                s.connect(sock_path)
+                if token is not None:
+                    s.sendall((json.dumps({"type": "auth", "token": token}) + "\n").encode())
+                message = {"type": "user", "message": {"role": "user", "content": text}}
+                s.sendall((json.dumps(message) + "\n").encode())
+                s.shutdown(socket.SHUT_WR)
+                reply = b""
+                try:
+                    while chunk := s.recv(65536):
+                        reply += chunk
+                except socket.timeout:
+                    pass  # sent; no answer is not a refusal (2.1.318 answers nothing)
+        except (OSError, ValueError, KeyError, TypeError, IndexError) as e:
+            raise DeliveryError(f"claude session {key}: {e}") from e
+        if b"error" in reply.lower():
+            answer = reply.decode(errors="replace").strip()
+            raise DeliveryError(f"claude session {key} refused: {answer}")
+
+    def configure(self, kaptyorka: str) -> List[str]:
+        lines = []
+        self.run(["claude", "mcp", "remove", "--scope", "user", "kaptyorka"],
+                 capture_output=True)
+        r = self.run(["claude", "mcp", "add", "--scope", "user", "kaptyorka", "--",
+                            kaptyorka, "mcp"], capture_output=True, text=True)
+        if r.returncode:
+            self.log(f"claude mcp add failed: {(r.stderr or r.stdout).strip()}")
+        else:
+            lines.append("Claude Code: kaptyorka MCP server registered (user scope)")
+
+        def add_hooks(data: dict) -> bool:
+            hooks = data.setdefault("hooks", {})
+            changed = False
+            for event, name in (("SessionStart", "start"), ("UserPromptSubmit", "prompt")):
+                command = f"{shlex.quote(kaptyorka)} hook claude-code {name}"
+                entry = {"hooks": [{"type": "command", "command": command, "timeout": 5}]}
+                entries = hooks.setdefault(event, [])
+                ours = [i for i, e in enumerate(entries) if any(
+                    str(h.get("command", "")).endswith(f" hook claude-code {name}")
+                    for h in e.get("hooks", []))]
+                if [entries[i] for i in ours] == [entry]:
+                    continue
+                for i in reversed(ours):  # an older install path: replace, never add a second
+                    del entries[i]
+                entries.insert(ours[0] if ours else len(entries), entry)
+                changed = True
+            return changed
+
+        settings = self.home / ".claude" / "settings.json"
+        result = merge_json(settings, add_hooks)
+        if result == "broken":
+            self.log(f"left alone, not valid JSON: {settings}")
+        elif result == "changed":
+            lines.append(f"Claude Code: kaptyorka hooks added to {settings}")
+        return lines
+
+    def unconfigure(self) -> List[str]:
+        lines = []
+        manual = "Claude Code: run `claude mcp remove --scope user kaptyorka` to remove the MCP server"
+        if not self.installed():
+            self.log(f"claude not found; {manual}")
+        else:
+            try:
+                r = self.run(["claude", "mcp", "remove", "--scope", "user", "kaptyorka"],
+                             capture_output=True, text=True)
+            except OSError as e:  # still remove the hooks below
+                self.log(f"claude failed: {e}; {manual}")
+            else:
+                if r.returncode == 0:
+                    lines.append("Claude Code: kaptyorka MCP server removed")
+
+        def drop(data: dict) -> bool:
+            hooks = data.get("hooks")
+            if not isinstance(hooks, dict):
+                return False
+            changed = drop_hooks(hooks, lambda h: is_our_hook(
+                h.get("command", ""), "claude-code", ("start", "prompt")))
+            if changed and not hooks:
+                del data["hooks"]
+            return changed
+
+        settings = self.home / ".claude" / "settings.json"
+        result = merge_json(settings, drop)
+        if result == "broken":
+            self.log(f"left alone, not valid JSON: {settings}")
+        elif result == "changed":
+            lines.append(f"Claude Code: kaptyorka hooks removed from {settings}")
+        return lines