overcode 0.3.3__tar.gz → 0.3.4__tar.gz

{overcode-0.3.3/src/overcode.egg-info → overcode-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: overcode
-Version: 0.3.3
+Version: 0.3.4
 Summary: A supervisor for managing multiple Claude Code instances in tmux
 Author: Mike Bond
 Project-URL: Homepage, https://github.com/mkb23/overcode

{overcode-0.3.3 → overcode-0.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "overcode"
-version = "0.3.3"
+version = "0.3.4"
 description = "A supervisor for managing multiple Claude Code instances in tmux"
 authors = [
     {name = "Mike Bond"}

{overcode-0.3.3 → overcode-0.3.4}/src/overcode/bundled_skills.py

@@ -248,6 +248,32 @@ Jobs are visible in the TUI jobs view (press `J`) and auto-clean after 24h (conf
 }
 
 
+def get_available_skills(project_dir: str | None = None) -> list[str]:
+    """Scan for installed skill directories (user-level + project-level).
+
+    Returns sorted list of skill names found in ~/.claude/skills/
+    and optionally .claude/skills/ relative to project_dir.
+    """
+    skills: set[str] = set()
+
+    # User-level skills
+    user_skills = Path.home() / ".claude" / "skills"
+    if user_skills.is_dir():
+        for d in user_skills.iterdir():
+            if d.is_dir() and (d / "SKILL.md").exists():
+                skills.add(d.name)
+
+    # Project-level skills
+    if project_dir:
+        proj_skills = Path(project_dir) / ".claude" / "skills"
+        if proj_skills.is_dir():
+            for d in proj_skills.iterdir():
+                if d.is_dir() and (d / "SKILL.md").exists():
+                    skills.add(d.name)
+
+    return sorted(skills)
+
+
 def any_skills_stale() -> bool:
     """Check if any installed skills are outdated vs bundled versions."""
     base = Path.home() / ".claude" / "skills"

{overcode-0.3.3 → overcode-0.3.4}/src/overcode/cli/config.py

@@ -44,8 +44,8 @@ CONFIG_TEMPLATE = """\
 #       start: "09:00"
 #       end: "17:00"
 
-# Time context hook settings (for 'overcode time-context')
-# time_context:
+# Enhanced context hook settings (agent identity, clock, presence, uptime)
+# enhanced_context:
 #   office_start: 9
 #   office_end: 17
 #   heartbeat_interval_minutes: 15  # omit to disable

{overcode-0.3.3 → overcode-0.3.4}/src/overcode/cli/monitoring.py

@@ -18,7 +18,7 @@ def hook_handler_cmd():
 
     Called by Claude Code hooks, not by users directly.
     Reads event JSON from stdin, writes state for status detection,
-    and outputs time-context for UserPromptSubmit events.
+    and outputs enhanced context for UserPromptSubmit events.
     """
     from ..hook_handler import handle_hook_event
 

{overcode-0.3.3 → overcode-0.3.4}/src/overcode/cli/split.py

@@ -263,20 +263,51 @@ def _setup_keybindings(linked_session: str = "", toggle_key: str = "") -> None:
     # --- Scrollback for the nested tmux in the bottom pane ---
     # The bottom pane runs a nested tmux client. The outer tmux
     # intercepts the prefix key, so copy-mode can't be entered
-    # normally. These bindings use `copy-mode -t` to directly enter
-    # copy mode in the inner session via the tmux API.
+    # normally.
+    #
+    # For local agents: use `copy-mode -t` to directly enter copy mode
+    # in the inner session via the tmux API (the linked session shares
+    # the actual agent panes, so scrollback is real).
+    #
+    # For SSH proxy windows (name starts with "ssh:"): the linked
+    # session pane is an SSH+tmux-attach client whose local scrollback
+    # is just rendering frames. Instead, forward PageUp/scroll through
+    # to the remote tmux which has the actual agent scrollback.
     if linked_session:
         # PageUp: enter copy mode + scroll up, but only when in the
         # bottom pane (pane_index != base) of the split window.
         # Top pane (Textual TUI) and other windows get normal PageUp.
+        #
+        # For SSH proxy windows: forward PageUp through the SSH pane
+        # so the *remote* tmux enters copy mode (the local proxy pane
+        # has no real scrollback — just rendered inner-tmux frames).
+        # For local agents: enter copy mode directly on the linked
+        # session which shares the real agent pane.
+        #
+        # Detection uses the @is_ssh_proxy window option (set by
+        # create_ssh_proxy_window) via a shell-based if-shell — this
+        # avoids tmux format expansion issues in stored bindings.
+        _ssh_check = (
+            f"tmux show-window-option -t {linked_session} -v @is_ssh_proxy "
+            "2>/dev/null | grep -q on"
+        )
         _tmux(
             "bind-key", "-n", "PPage",
             "if-shell", "-F",
             f"#{{&&:#{{==:#{{window_name}},{SPLIT_WINDOW_NAME}}},#{{!=:#{{pane_index}},{_base}}}}}",
-            f"copy-mode -t {linked_session} -u",
+            # SSH proxy: send prefix + PPage so the REMOTE tmux enters
+            # copy mode (the remote's root-table PPage is overridden by
+            # overcode, but prefix PPage still maps to copy-mode -u).
+            # Local: enter copy mode directly on the linked session.
+            f'if-shell "{_ssh_check}" '
+            f'"send-keys -t {linked_session} C-b ; '
+            f'send-keys -t {linked_session} PPage" '
+            f'"copy-mode -t {linked_session} -u"',
             "send-keys PPage",
         )
         # PageDown in the inner session's copy mode
+        # (send-keys works for both local and SSH proxy — for local it
+        # controls copy mode, for SSH proxy it forwards to remote tmux)
         _tmux(
             "bind-key", "-n", "NPage",
             "if-shell", "-F",
@@ -288,8 +319,9 @@ def _setup_keybindings(linked_session: str = "", toggle_key: str = "") -> None:
         # Without this, scrolling enters copy mode in the outer pane
         # which has no scrollback (just rendered inner tmux frames).
         #
-        # Strategy: enter copy mode in the inner session (no-op if
-        # already active), then send scroll-up/down commands to it.
+        # For local agents: enter copy mode in the inner session then
+        # send scroll commands. For SSH proxies: forward mouse events
+        # to the remote tmux through the pane.
         _in_bottom = (
             f"#{{&&:#{{==:#{{window_name}},{SPLIT_WINDOW_NAME}}},"
             f"#{{!=:#{{pane_index}},{_base}}}}}"
@@ -297,8 +329,14 @@ def _setup_keybindings(linked_session: str = "", toggle_key: str = "") -> None:
         _tmux(
             "bind-key", "-n", "WheelUpPane",
             "if-shell", "-F", _in_bottom,
-            f"copy-mode -t {linked_session} -e ; "
-            f"send-keys -t {linked_session} -X -N 3 scroll-up",
+            # SSH proxy: send prefix+PPage to enter copy mode on remote
+            # (no-op if already in copy mode, then PPage scrolls up).
+            # Local: enter copy mode + scroll up directly.
+            f'if-shell "{_ssh_check}" '
+            f'"send-keys -t {linked_session} C-b ; '
+            f'send-keys -t {linked_session} PPage" '
+            f'"copy-mode -t {linked_session} -e ; '
+            f'send-keys -t {linked_session} -X -N 3 scroll-up"',
             # Default behaviour for other contexts
             "if-shell -F '#{||:#{pane_in_mode},#{mouse_any_flag}}' "
             "'send-keys -M' 'copy-mode -e'",
@@ -306,7 +344,11 @@ def _setup_keybindings(linked_session: str = "", toggle_key: str = "") -> None:
         _tmux(
             "bind-key", "-n", "WheelDownPane",
             "if-shell", "-F", _in_bottom,
-            f"send-keys -t {linked_session} -X -N 3 scroll-down",
+            # SSH proxy: send NPage to remote (works in copy mode).
+            # Local: send scroll-down in local copy mode.
+            f'if-shell "{_ssh_check}" '
+            f'"send-keys -t {linked_session} NPage" '
+            f'"send-keys -t {linked_session} -X -N 3 scroll-down"',
             "send-keys -M",
         )
 

{overcode-0.3.3 → overcode-0.3.4}/src/overcode/config.py

@@ -197,23 +197,35 @@ def get_web_time_presets() -> list:
     ]
 
 
-def get_time_context_config() -> dict:
-    """Get time context configuration for the time-context hook.
+def get_enhanced_context_config() -> dict:
+    """Get enhanced context configuration for the enhanced-context hook.
 
     Config format in ~/.overcode/config.yaml:
-        time_context:
+        enhanced_context:
           office_start: 9
           office_end: 17
           heartbeat_interval_minutes: 15  # omit to disable
 
+    Falls back to legacy 'time_context' key for backwards compatibility.
+
     Returns:
         Dict with office_start (int), office_end (int),
         heartbeat_interval_minutes (Optional[int])
     """
+    # Try new key first, fall back to legacy key
+    office_start = _get_config_value("enhanced_context.office_start")
+    if office_start is None:
+        office_start = _get_config_value("time_context.office_start", 9)
+    office_end = _get_config_value("enhanced_context.office_end")
+    if office_end is None:
+        office_end = _get_config_value("time_context.office_end", 17)
+    hb_interval = _get_config_value("enhanced_context.heartbeat_interval_minutes")
+    if hb_interval is None:
+        hb_interval = _get_config_value("time_context.heartbeat_interval_minutes")
     return {
-        "office_start": _get_config_value("time_context.office_start", 9),
-        "office_end": _get_config_value("time_context.office_end", 17),
-        "heartbeat_interval_minutes": _get_config_value("time_context.heartbeat_interval_minutes"),
+        "office_start": office_start,
+        "office_end": office_end,
+        "heartbeat_interval_minutes": hb_interval,
     }
 
 
@@ -365,9 +377,11 @@ def get_sisters_config() -> List[dict]:
           - name: "desktop"
             url: "http://localhost:25337"
             api_key: "secret"
+            ssh: "user@desktop"        # optional: enables tmux attach + auto-provisioning
+            tmux_session: "agents"     # optional: remote tmux session name (default: "agents")
 
     Returns:
-        List of dicts with name, url, and optional api_key. Empty list if unconfigured.
+        List of dicts with name, url, and optional api_key/ssh/tmux_session. Empty list if unconfigured.
     """
     sisters = _get_config_value("sisters", [])
     if not isinstance(sisters, list):
@@ -385,6 +399,13 @@ def get_sisters_config() -> List[dict]:
         api_key = s.get("api_key")
         if api_key:
             entry["api_key"] = api_key
+        # SSH connectivity (optional)
+        ssh = s.get("ssh")
+        if ssh:
+            entry["ssh"] = ssh
+        tmux_session = s.get("tmux_session")
+        if tmux_session:
+            entry["tmux_session"] = tmux_session
         result.append(entry)
 
     return result

{overcode-0.3.3 → overcode-0.3.4}/src/overcode/dependency_check.py

@@ -15,13 +15,45 @@ from .exceptions import TmuxNotFoundError, ClaudeNotFoundError
 def find_executable(name: str) -> Optional[str]:
     """Find the path to an executable.
 
+    Checks PATH first, then common install locations that may not be on PATH
+    in non-login shells (e.g., web server subprocesses, SSH non-interactive).
+
     Args:
         name: Name of the executable
 
     Returns:
         Full path to executable, or None if not found
     """
-    return shutil.which(name)
+    import os
+    from pathlib import Path
+
+    path = shutil.which(name)
+    if path:
+        return path
+
+    # Check common locations not always on PATH in non-login shells
+    return _find_in_fallback_dirs(name)
+
+
+def _find_in_fallback_dirs(name: str) -> Optional[str]:
+    """Check common install directories for an executable."""
+    import os
+    from pathlib import Path
+
+    home = Path.home()
+    fallback_dirs = [
+        home / ".local" / "bin",           # pip/pipx, claude CLI
+        home / ".npm-global" / "bin",      # npm global
+        home / ".nvm" / "current" / "bin", # nvm
+        Path("/usr/local/bin"),
+        Path("/opt/homebrew/bin"),          # macOS ARM homebrew
+    ]
+    for d in fallback_dirs:
+        candidate = d / name
+        if candidate.is_file() and os.access(candidate, os.X_OK):
+            return str(candidate)
+
+    return None
 
 
 def _check_executable(

{overcode-0.3.3 → overcode-0.3.4}/src/overcode/hook_handler.py

@@ -2,7 +2,7 @@
 
 A single command (`overcode hook-handler`) handles all hook events.
 It reads stdin JSON from Claude Code, writes state files for hook-based
-status detection, and outputs time-context for UserPromptSubmit events.
+status detection, and outputs enhanced context for UserPromptSubmit events.
 
 Hook registrations (all use the same command):
     UserPromptSubmit  -> overcode hook-handler
@@ -110,7 +110,7 @@ def handle_hook_event() -> None:
     # Write state file for status detection
     write_hook_state(event, tmux_session, session_name, tool_name=tool_name, tool_input=tool_input)
 
-    # For UserPromptSubmit, check budget and output time-context
+    # For UserPromptSubmit, check budget and output enhanced context
     if event == "UserPromptSubmit":
         from .time_context import _load_daemon_state, _find_session_in_state
 
@@ -127,8 +127,8 @@ def handle_hook_event() -> None:
                 )
                 sys.exit(2)
 
-        from .time_context import generate_time_context
+        from .time_context import generate_enhanced_context
 
-        line = generate_time_context(tmux_session, session_name)
+        line = generate_enhanced_context(tmux_session, session_name)
         if line:
             print(line)

{overcode-0.3.3 → overcode-0.3.4}/src/overcode/hook_status_detector.py

@@ -95,6 +95,8 @@ class HookStatusDetector:
         # Diagnostic phase tracking (same interface as PollingStatusDetector)
         self._last_detect_phase: Dict[str, str] = {}
         self._content_changed: Dict[str, bool] = {}
+        # Skills observed via Skill tool_use events, keyed by session name (#252)
+        self._loaded_skills: Dict[str, set] = {}
 
         # Resolve state directory — must match hook_handler._get_hook_state_path()
         if state_dir is not None:
@@ -180,6 +182,17 @@ class HookStatusDetector:
             self._last_detect_phase[session.id] = "hook:no_state"
             return STATUS_WAITING_USER, "Waiting for first hook event", pane_content
 
+        # Track Skill tool_use events (#252)
+        tool_name = hook_state.get("tool_name")
+        if tool_name == "Skill":
+            tool_input = hook_state.get("tool_input")
+            if isinstance(tool_input, dict):
+                skill_name = tool_input.get("skill", "")
+                if skill_name:
+                    if session.name not in self._loaded_skills:
+                        self._loaded_skills[session.name] = set()
+                    self._loaded_skills[session.name].add(skill_name)
+
         # Hook state exists — use it for status
         event = hook_state.get("event", "")
 
@@ -308,3 +321,8 @@ class HookStatusDetector:
             return "Claude exited"
 
         return "Unknown state"
+
+    def get_loaded_skills(self, session_name: str) -> list[str]:
+        """Return skills observed via Skill tool_use for a session (#252)."""
+        skills = self._loaded_skills.get(session_name, set())
+        return sorted(skills)

{overcode-0.3.3 → overcode-0.3.4}/src/overcode/monitor_daemon.py

@@ -312,6 +312,10 @@ class MonitorDaemon:
         self._last_session_id_sync: Optional[datetime] = None
         self._session_id_sync_interval = 10  # seconds
 
+        # Available skills sync (#252) — infrequent, skills rarely change
+        self._last_skills_sync: Optional[datetime] = None
+        self._skills_sync_interval = 60  # seconds
+
         # Relay configuration (for pushing state to cloud)
         self._relay_config = get_relay_config()
         self._last_relay_push = datetime.min
@@ -452,7 +456,7 @@ class MonitorDaemon:
             permissiveness_mode=session.permissiveness_mode,
             start_directory=session.start_directory,
             is_asleep=session.is_asleep,
-            time_context_enabled=session.time_context_enabled,
+            enhanced_context_enabled=session.enhanced_context_enabled,
             agent_value=session.agent_value,
             # Heartbeat state (#171)
             heartbeat_enabled=session.heartbeat_enabled,
@@ -899,6 +903,7 @@ class MonitorDaemon:
             self._legacy_windows_migrated = True
         self._sync_session_ids(sessions, now)
         self._sync_session_stats(sessions, now)
+        self._sync_available_skills(sessions, now)
         self._dispatch_heartbeats(sessions)
         session_states, all_waiting = self._detect_and_enrich(sessions, now)
         self._cleanup_stale(sessions)
@@ -924,6 +929,16 @@ class MonitorDaemon:
                 self.sync_claude_code_stats(session)
             self._last_stats_sync = now
 
+    def _sync_available_skills(self, sessions: list, now: datetime) -> None:
+        """Scan installed skill directories every 60s (#252)."""
+        if should_sync_stats(self._last_skills_sync, now, self._skills_sync_interval):
+            from .bundled_skills import get_available_skills
+            for session in sessions:
+                available = get_available_skills(session.start_directory)
+                if available != session.available_skills:
+                    self.session_manager.update_session(session.id, available_skills=available)
+            self._last_skills_sync = now
+
     def _dispatch_heartbeats(self, sessions: list) -> None:
         """Send heartbeats before status detection (#171)."""
         self._heartbeat_triggered_sessions = self.check_and_send_heartbeats(sessions)
@@ -952,6 +967,12 @@ class MonitorDaemon:
                 # Log hook events when they change (diagnostic visibility)
                 self._log_hook_event(session, status, activity)
 
+                # Track loaded skills from hook events (#252)
+                if hasattr(self.detector, 'get_loaded_skills'):
+                    new_skills = self.detector.get_loaded_skills(session.name)
+                    if new_skills and sorted(new_skills) != sorted(session.loaded_skills):
+                        self.session_manager.update_session(session.id, loaded_skills=new_skills)
+
                 # Extract PR number from pane content
                 if pane_content:
                     pr = extract_pr_number(pane_content)
@@ -985,9 +1006,10 @@ class MonitorDaemon:
                 continue
 
             # Track stats and build state
-            # Use "asleep" status if session is marked as sleeping (#68)
-            # Use "running_heartbeat" if running due to heartbeat trigger (#171)
-            if session.is_asleep:
+            # Precedence: terminated > asleep > heartbeat variants > default (#399, #68, #171)
+            if status == STATUS_TERMINATED:
+                effective_status = STATUS_TERMINATED
+            elif session.is_asleep:
                 effective_status = STATUS_ASLEEP
             elif status == STATUS_RUNNING and session.id in self._sessions_running_from_heartbeat:
                 if session.id in self._heartbeat_start_pending:

{overcode-0.3.3 → overcode-0.3.4}/src/overcode/monitor_daemon_state.py

@@ -76,7 +76,7 @@ class SessionDaemonState:
     permissiveness_mode: str = "normal"  # normal, permissive, bypass
     start_directory: Optional[str] = None  # For git diff stats
     is_asleep: bool = False  # Agent is paused and excluded from stats (#70)
-    time_context_enabled: bool = False  # Per-agent time awareness toggle
+    enhanced_context_enabled: bool = False  # Per-agent enhanced context toggle
 
     # Agent priority value (#61)
     agent_value: int = 1000  # Default 1000, higher = more important

{overcode-0.3.3 → overcode-0.3.4}/src/overcode/session_manager.py

@@ -97,8 +97,8 @@ class Session:
     # Sleep mode - agent is paused and excluded from stats
     is_asleep: bool = False
 
-    # Time context hook - per-agent toggle for time awareness injection
-    time_context_enabled: bool = False
+    # Enhanced context hook - per-agent toggle for enhanced context injection
+    enhanced_context_enabled: bool = False
 
     # Agent value - priority indicator for sorting/attention (#61)
     # Default 1000, higher = more important
@@ -129,6 +129,10 @@ class Session:
     # Hook-based status detection - per-agent toggle (#5)
     hook_status_detection: bool = True
 
+    # Skills loaded during this session (#252)
+    loaded_skills: List[str] = field(default_factory=list)
+    available_skills: List[str] = field(default_factory=list)
+
     # Claude CLI flag passthrough (#290)
     allowed_tools: Optional[str] = None  # Comma-separated tool list for --allowedTools
     extra_claude_args: List[str] = field(default_factory=list)  # Extra CLI flags via --claude-arg
@@ -158,6 +162,10 @@ class Session:
     remote_activity_summary_context: str = ""  # AI context summary from remote summarizer
     remote_daemon_state: Optional[dict] = None  # Raw daemon state dict from sister API (for generic forwarding)
 
+    # SSH connectivity for remote agents
+    source_ssh: str = ""  # SSH target (e.g., "user@host") for tmux attach
+    source_tmux_session: str = ""  # Remote tmux session name (default: "agents")
+
     def to_dict(self) -> dict:
         # asdict() recursively converts nested dataclasses (stats)
         return asdict(self)
@@ -193,6 +201,10 @@ class Session:
         if 'tmux_window' in filtered and isinstance(filtered['tmux_window'], int):
             filtered['tmux_window'] = str(filtered['tmux_window'])
 
+        # Backward compat: migrate time_context_enabled → enhanced_context_enabled (#378)
+        if 'enhanced_context_enabled' not in filtered and 'time_context_enabled' in data:
+            filtered['enhanced_context_enabled'] = data['time_context_enabled']
+
         try:
             return cls(**filtered)
         except TypeError:

{overcode-0.3.3 → overcode-0.3.4}/src/overcode/settings.py

@@ -262,6 +262,9 @@ class UserConfig:
     # Per-model pricing overrides (loaded from config.yaml model_pricing section)
     model_pricing: dict = field(default_factory=dict)
 
+    # Skill emoji overrides (loaded from config.yaml skill_emoji section) (#252)
+    skill_emoji: dict = field(default_factory=dict)
+
     @classmethod
     def load(cls) -> "UserConfig":
         """Load configuration from config file."""
@@ -292,6 +295,13 @@ class UserConfig:
                                 cache_read=vals.get("cache_read", 0.30),
                             )
 
+                # Parse skill emoji overrides (#252)
+                skill_emoji_raw = data.get("skill_emoji", {})
+                skill_emoji_parsed = (
+                    {str(k): str(v) for k, v in skill_emoji_raw.items()}
+                    if isinstance(skill_emoji_raw, dict) else {}
+                )
+
                 return cls(
                     default_standing_instructions=data.get(
                         "default_standing_instructions", ""
@@ -302,6 +312,7 @@ class UserConfig:
                     price_cache_write=pricing.get("cache_write", 3.75),
                     price_cache_read=pricing.get("cache_read", 0.30),
                     model_pricing=model_pricing_parsed,
+                    skill_emoji=skill_emoji_parsed,
                 )
         except (yaml.YAMLError, IOError):
             return cls()
@@ -439,6 +450,11 @@ def resolve_detection_mode(session: str) -> str:
     return "hooks" if ClaudeConfigEditor.are_overcode_hooks_installed() else "polling"
 
 
+def get_tui_log_path(session: str) -> Path:
+    """Get the TUI diagnostic log file path for a specific session."""
+    return get_session_dir(session) / "tui.log"
+
+
 def get_diagnostics_dir(session: str) -> Path:
     """Get the diagnostics directory for a specific session."""
     return get_session_dir(session) / "diagnostics"
@@ -521,6 +537,7 @@ class TUIPreferences:
     summary_detail: str = "full"  # low, med, full
     timeline_visible: bool = True
     daemon_panel_visible: bool = False
+    tui_log_panel_visible: bool = False
     preview_visible: bool = False  # preview pane visibility
     tmux_sync: bool = False  # sync navigation to external tmux pane
     show_terminated: bool = False  # keep killed sessions visible in timeline

{overcode-0.3.3 → overcode-0.3.4}/src/overcode/sister_controller.py

@@ -6,11 +6,14 @@ request to the sister's web API and returns a Result.
 """
 
 import json
+import logging
 from dataclasses import dataclass
 from typing import Optional
 from urllib.error import HTTPError, URLError
 from urllib.request import Request, urlopen
 
+_log = logging.getLogger("overcode.sister")
+
 
 @dataclass
 class ControlResult:
@@ -40,6 +43,7 @@ class SisterController:
     ) -> ControlResult:
         """Send an HTTP request to a sister's control API."""
         url = f"{sister_url.rstrip('/')}{path}"
+        _log.debug("HTTP %s %s body=%s", method, url, body)
 
         data = json.dumps(body or {}).encode("utf-8")
         req = Request(url, data=data, method=method)
@@ -50,14 +54,18 @@ class SisterController:
         try:
             with urlopen(req, timeout=self.timeout) as resp:
                 result = json.loads(resp.read().decode("utf-8"))
+                _log.debug("HTTP %s %s -> ok=%s", method, url, result.get("ok", True))
                 return ControlResult(ok=result.get("ok", True), data=result)
         except HTTPError as e:
             try:
                 error_body = json.loads(e.read().decode("utf-8"))
-                return ControlResult(ok=False, error=error_body.get("error", str(e)))
+                error_msg = error_body.get("error", str(e))
             except (json.JSONDecodeError, UnicodeDecodeError):
-                return ControlResult(ok=False, error=f"HTTP {e.code}: {e.reason}")
+                error_msg = f"HTTP {e.code}: {e.reason}"
+            _log.error("HTTP %s %s -> HTTPError %s: %s", method, url, e.code, error_msg)
+            return ControlResult(ok=False, error=error_msg)
         except (URLError, OSError) as e:
+            _log.error("HTTP %s %s -> ConnectionError: %s", method, url, e)
             return ControlResult(ok=False, error=f"Connection error: {e}")
 
     # --- Agent Interaction ---
@@ -122,6 +130,16 @@ class SisterController:
             {"name": fork_name, "prompt": prompt},
         )
 
+    def resize_agent(
+        self, sister_url: str, api_key: str, agent_name: str,
+        width: int, height: int,
+    ) -> ControlResult:
+        return self._request(
+            "POST", sister_url, api_key,
+            f"/api/agents/{agent_name}/resize",
+            {"width": width, "height": height},
+        )
+
     # --- Agent Configuration ---
 
     def set_standing_orders(
@@ -220,12 +238,12 @@ class SisterController:
 
     # --- Feature Toggles ---
 
-    def set_time_context(
+    def set_enhanced_context(
         self, sister_url: str, api_key: str, agent_name: str, enabled: bool,
     ) -> ControlResult:
         return self._request(
             "PUT", sister_url, api_key,
-            f"/api/agents/{agent_name}/time-context",
+            f"/api/agents/{agent_name}/enhanced-context",
             {"enabled": enabled},
         )