overcode 0.2.3__tar.gz → 0.2.5__tar.gz

{overcode-0.2.3/src/overcode.egg-info → overcode-0.2.5}/PKG-INFO

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

{overcode-0.2.3 → overcode-0.2.5}/pyproject.toml

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

{overcode-0.2.3 → overcode-0.2.5}/src/overcode/cli/agent.py

@@ -464,6 +464,11 @@ def list_agents(
     if terminated_count > 0:
         rprint(f"\n[dim]{terminated_count} terminated session(s). Run 'overcode cleanup' to remove.[/dim]")
 
+    # Hint about untracked tmux windows (#344)
+    if use_daemon and daemon_state.untracked_window_count > 0:
+        n = daemon_state.untracked_window_count
+        rprint(f"\n[dim]{n} untracked tmux window(s). Run 'overcode cleanup --untracked' to remove.[/dim]")
+
 
 @app.command()
 def attach(
@@ -598,6 +603,9 @@ def cleanup(
     done: Annotated[
         bool, typer.Option("--done", help="Also archive 'done' child agents (#244)")
     ] = False,
+    untracked: Annotated[
+        bool, typer.Option("--untracked", help="Kill tmux windows not tracked by any agent (#344)")
+    ] = False,
     session: SessionOption = "agents",
 ):
     """Remove terminated sessions from tracking.
@@ -606,6 +614,7 @@ def cleanup(
     (e.g., after a machine reboot). Use 'overcode list' to see them.
 
     Use --done to also archive done child agents (kill tmux window, move to archive).
+    Use --untracked to kill tmux windows that exist but aren't tracked by any agent.
     """
     launcher = ClaudeLauncher(session)
     count = launcher.cleanup_terminated_sessions()
@@ -619,6 +628,10 @@ def cleanup(
             launcher._kill_single_session(sess)
             done_count += 1
 
+    # Kill untracked tmux windows (#344)
+    if untracked:
+        launcher.list_sessions(kill_untracked=True)
+
     total = count + done_count
     if total > 0:
         parts = []
@@ -627,7 +640,7 @@ def cleanup(
         if done_count > 0:
             parts.append(f"{done_count} done")
         rprint(f"[green]✓ Cleaned up {' + '.join(parts)} session(s)[/green]")
-    else:
+    elif not untracked:
         rprint("[dim]No sessions to clean up[/dim]")
 
 

{overcode-0.2.3 → overcode-0.2.5}/src/overcode/implementations.py

@@ -151,6 +151,17 @@ class RealTmux:
                     if rest:
                         pane.send_keys(rest, enter=False)
                         time.sleep(0.1)
+                elif keys.startswith('/') and len(keys) > 1:
+                    # Special handling for slash commands (#307)
+                    # Claude Code shows a command menu when / is typed;
+                    # send / separately so the menu has time to appear
+                    # before the rest of the command and Enter arrive.
+                    pane.send_keys('/', enter=False)
+                    time.sleep(0.3)
+                    rest = keys[1:]
+                    if rest:
+                        pane.send_keys(rest, enter=False)
+                        time.sleep(0.15)
                 else:
                     pane.send_keys(keys, enter=False)
                     # Small delay for Claude Code to process text

{overcode-0.2.3 → overcode-0.2.5}/src/overcode/monitor_daemon.py

@@ -679,14 +679,37 @@ class MonitorDaemon:
 
             # Archive: kill tmux window and mark terminated
             try:
-                from .tmux_utils import TmuxHelper
-                tmux = TmuxHelper()
+                from .implementations import RealTmux
+                tmux = RealTmux()
                 tmux.kill_window(self.tmux_session, session.tmux_window)
             except Exception:
                 pass  # Window may already be gone
             self.session_manager.update_session_status(session.id, "terminated")
             self.log.info(f"Auto-archived done agent: {session.name}")
 
+    def _count_untracked_windows(self, sessions: list) -> int:
+        """Count tmux windows not tracked by any active session (#344).
+
+        Returns count of windows that exist in tmux but aren't tracked
+        (excluding window 0 which is the default shell).
+        """
+        try:
+            from .implementations import RealTmux
+            tmux = RealTmux()
+            if not tmux.session_exists(self.tmux_session):
+                return 0
+            tmux_windows = tmux.list_windows(self.tmux_session)
+            active_sessions = [s for s in sessions if s.status != "terminated"]
+            tracked_windows = {s.tmux_window for s in active_sessions}
+            count = 0
+            for window_info in tmux_windows:
+                window_idx = int(window_info['index'])
+                if window_idx != 0 and window_idx not in tracked_windows:
+                    count += 1
+            return count
+        except Exception:
+            return 0
+
     def _enforce_oversight_timeouts(self, sessions: list) -> None:
         """Enforce oversight timeouts for waiting_oversight sessions."""
         now = datetime.now()
@@ -849,12 +872,30 @@ class MonitorDaemon:
         session_states = []
         all_waiting_user = True
 
+        # Detect window index collisions: when multiple sessions share
+        # a window index, only the most recently launched one owns it.
+        # Others are truly terminated (their window was reused).
+        from collections import Counter
+        window_counts = Counter(s.tmux_window for s in sessions if s.status != "done")
+        # For colliding windows, find the rightful owner (latest start_time)
+        window_owner = {}
+        for s in sessions:
+            if s.status == "done":
+                continue
+            w = s.tmux_window
+            if window_counts[w] > 1:
+                # Multiple sessions claim this window — latest launch wins
+                if w not in window_owner or s.start_time > window_owner[w].start_time:
+                    window_owner[w] = s
+
         for session in sessions:
-            # Skip sessions already known to be terminated/done —
-            # avoids a wasted tmux call and prevents desync where
-            # detect_status returns waiting_user for a gone window.
-            if session.status == "terminated":
+            # If this window is contested and we're not the owner, skip
+            pane_content = ""
+            if (window_counts.get(session.tmux_window, 0) > 1
+                    and window_owner.get(session.tmux_window) is not session):
                 status, activity = STATUS_TERMINATED, "Session terminated"
+                if session.status != "terminated":
+                    self.session_manager.update_session_status(session.id, "terminated")
             elif session.status == "done":
                 status, activity = STATUS_DONE, "Completed"
             else:
@@ -912,9 +953,17 @@ class MonitorDaemon:
             else:
                 effective_status = status
 
-            # Persist terminated status so future loops skip detect_status
-            if effective_status == STATUS_TERMINATED and session.status != "terminated":
+            # Persist terminated status when window is truly gone.
+            # Only persist when pane_content is empty (window gone), not when
+            # a shell prompt is briefly visible (e.g. during agent revival).
+            if (effective_status == STATUS_TERMINATED
+                    and session.status != "terminated"
+                    and not pane_content):
                 self.session_manager.update_session_status(session.id, "terminated")
+            # Un-persist terminated if agent is found alive (revival or false positive)
+            elif (session.status == "terminated"
+                    and effective_status != STATUS_TERMINATED):
+                self.session_manager.update_session_status(session.id, "running")
 
             session_state = self.track_session_stats(session, effective_status)
             session_state.current_activity = activity
@@ -981,8 +1030,10 @@ class MonitorDaemon:
         self._enforce_oversight_timeouts(sessions)
 
         # Auto-archive "done" agents after 1 hour (#244)
+        # Count untracked tmux windows every 2 minutes (#344)
         if self.state.loop_count % 60 == 0:
             self._auto_archive_done_agents(sessions)
+            self.state.untracked_window_count = self._count_untracked_windows(sessions)
 
         # Log summary
         green = sum(1 for s in session_states if s.current_status == STATUS_RUNNING)

{overcode-0.2.3 → overcode-0.2.5}/src/overcode/monitor_daemon_state.py

@@ -174,6 +174,9 @@ class MonitorDaemonState:
     relay_last_push: Optional[str] = None  # ISO timestamp of last successful push
     relay_last_status: str = "disabled"  # "ok", "error", "disabled"
 
+    # Untracked tmux windows (#344)
+    untracked_window_count: int = 0
+
     def to_dict(self) -> dict:
         """Convert to dictionary for JSON serialization."""
         return dataclasses.asdict(self)

{overcode-0.2.3 → overcode-0.2.5}/src/overcode/settings.py

@@ -425,6 +425,7 @@ class TUIPreferences:
     summary_content_mode: str = "ai_short"  # ai_short, ai_long, orders, annotation, heartbeat (#98, #171)
     baseline_minutes: int = 60  # 0=now (instantaneous), 15/30/.../180 = minutes back for mean spin
     monochrome: bool = False  # B&W mode for terminals with ANSI issues (#138)
+    emoji_free: bool = False  # ASCII fallbacks for terminals without emoji (#315)
     show_cost: bool = False  # Show $ cost instead of token counts
     timeline_hours: float = 3.0  # 1, 3, 6, 12, 24 — timeline scope (#191)
     notifications: str = "off"  # "off", "sound", "banner", "both" — macOS notifications (#235)
@@ -435,6 +436,8 @@ class TUIPreferences:
     column_config: dict = field(default_factory=dict)
     # Show abbreviated column headers above summary lines
     show_column_headers: bool = False
+    # Sister instances hidden from agent list (#323)
+    disabled_sisters: Set[str] = field(default_factory=set)
 
     @classmethod
     def load(cls, session: str) -> "TUIPreferences":
@@ -470,12 +473,14 @@ class TUIPreferences:
                     summary_content_mode=data.get("summary_content_mode", "ai_short"),
                     baseline_minutes=data.get("baseline_minutes", 0),
                     monochrome=data.get("monochrome", False),
+                    emoji_free=data.get("emoji_free", False),
                     show_cost=data.get("show_cost", False),
                     visited_stalled_agents=set(data.get("visited_stalled_agents", [])),
                     column_config=data.get("column_config", {}),
                     show_column_headers=data.get("show_column_headers", False),
                     timeline_hours=data.get("timeline_hours", 3.0),
                     notifications=data.get("notifications", "off"),
+                    disabled_sisters=set(data.get("disabled_sisters", [])),
                 )
         except (json.JSONDecodeError, IOError):
             return cls()
@@ -502,12 +507,14 @@ class TUIPreferences:
                     "summary_content_mode": self.summary_content_mode,
                     "baseline_minutes": self.baseline_minutes,
                     "monochrome": self.monochrome,
+                    "emoji_free": self.emoji_free,
                     "show_cost": self.show_cost,
                     "visited_stalled_agents": list(self.visited_stalled_agents),
                     "column_config": self.column_config,
                     "show_column_headers": self.show_column_headers,
                     "timeline_hours": self.timeline_hours,
                     "notifications": self.notifications,
+                    "disabled_sisters": sorted(self.disabled_sisters),
                 }, f, indent=2)
         except (IOError, OSError):
             pass  # Best effort

{overcode-0.2.3 → overcode-0.2.5}/src/overcode/status_constants.py

@@ -93,9 +93,86 @@ STATUS_EMOJIS = {
 }
 
 
-def get_status_emoji(status: str) -> str:
+# ASCII fallbacks for all emoji used in the TUI (#315)
+# Used when emoji_free mode is active (terminals without emoji font support).
+EMOJI_ASCII = {
+    # Status indicators
+    "🟢": "[R]",
+    "🔴": "[W]",
+    "⚫": "[X]",
+    "💤": "[Z]",
+    "💚": "[H]",
+    "🟠": "[A]",
+    "💛": "[h]",
+    "🟣": "[E]",
+    "☑️": "[D]",
+    "👁️": "[O]",
+    "🟡": "[S]",
+    "⚪": "[?]",
+    # Tool indicators
+    "🖥️": "Sh",
+    "📖": "Rd",
+    "✏️": "Wr",
+    "🔧": "Ed",
+    "🔍": "Gl",
+    "🔎": "Gr",
+    "🌐": "Wf",
+    "🕵️": "Ws",
+    "🧵": "Tk",
+    "📓": "Nb",
+    "📋": "Cb",
+    "📝": "Tw",
+    "🔹": "--",
+    # Permission modes
+    "🔥": "B!",
+    "🏃": "P>",
+    "👮": "N:",
+    # Activity/metrics
+    "🔔": "(!)",
+    "⏰": "AL",
+    "📚": "CW",
+    "💓": "<3",
+    "💰": "$$",
+    "⏳": "~~",
+    "🤖": "Ro",
+    "👤": "Hu",
+    "🤿": "Su",
+    "🐚": "Bg",
+    "👶": "Ch",
+    "🤝": "Tm",
+    "🕐": "Tc",
+    # Content modes
+    "💬": "Sm",
+    "🎯": "SO",
+    # Presence states
+    "⏻": "Pw",
+    "🔒": "Lk",
+    "🧘": "Id",
+    "🚶": "Ac",
+    # Value arrows
+    "⏫️": "^^",
+    "⏬️": "vv",
+    "⏹️": "==",
+    # Misc
+    "⚠": "!W",
+    "➖": "--",
+    "✓": "ok",
+    "▼": "v ",
+    "▶": "> ",
+}
+
+
+def emoji_or_ascii(char: str, emoji_free: bool) -> str:
+    """Return ASCII fallback if emoji_free mode is active, else the emoji."""
+    if emoji_free:
+        return EMOJI_ASCII.get(char, char)
+    return char
+
+
+def get_status_emoji(status: str, emoji_free: bool = False) -> str:
     """Get emoji for an agent status."""
-    return STATUS_EMOJIS.get(status, "⚪")
+    e = STATUS_EMOJIS.get(status, "⚪")
+    return emoji_or_ascii(e, emoji_free)
 
 
 # =============================================================================
@@ -143,9 +220,10 @@ STATUS_SYMBOLS = {
 }
 
 
-def get_status_symbol(status: str) -> Tuple[str, str]:
+def get_status_symbol(status: str, emoji_free: bool = False) -> Tuple[str, str]:
     """Get (emoji, color) tuple for an agent status."""
-    return STATUS_SYMBOLS.get(status, ("⚪", "dim"))
+    symbol, color = STATUS_SYMBOLS.get(status, ("⚪", "dim"))
+    return (emoji_or_ascii(symbol, emoji_free), color)
 
 
 # =============================================================================

{overcode-0.2.3 → overcode-0.2.5}/src/overcode/summary_columns.py

@@ -49,14 +49,16 @@ TOOL_EMOJI_DEFAULT = "🔹"  # Fallback for unknown tools
 MAX_TOOL_EMOJI = 10  # Configurable cap
 
 
-def _tool_emojis(allowed_tools: Optional[str], max_n: int = MAX_TOOL_EMOJI) -> str:
+def _tool_emojis(allowed_tools: Optional[str], max_n: int = MAX_TOOL_EMOJI, emoji_free: bool = False) -> str:
     """Convert comma-separated tool names to emoji string."""
     if not allowed_tools:
         return ""
+    from .status_constants import emoji_or_ascii
     tools = [t.strip() for t in allowed_tools.split(",") if t.strip()]
-    emojis = [TOOL_EMOJI.get(t, TOOL_EMOJI_DEFAULT) for t in tools[:max_n]]
+    emojis = [emoji_or_ascii(TOOL_EMOJI.get(t, TOOL_EMOJI_DEFAULT), emoji_free) for t in tools[:max_n]]
+    sep = " " if emoji_free else ""
     suffix = "…" if len(tools) > max_n else ""
-    return "".join(emojis) + suffix
+    return sep.join(emojis) + suffix
 
 
 # ---------------------------------------------------------------------------
@@ -93,6 +95,7 @@ class ColumnContext:
     status_color: str
     bg: str  # background style suffix, e.g. " on #0d2137" or ""
     monochrome: bool
+    emoji_free: bool
     summary_detail: str
     show_cost: bool
     any_has_budget: bool  # True if any agent has a cost budget (#173)
@@ -153,8 +156,15 @@ class ColumnContext:
     local_hostname: str = ""
 
     def mono(self, colored: str, simple: str = "bold") -> str:
-        """Return simplified style when monochrome is enabled."""
-        return simple if self.monochrome else colored
+        """Return colored style (monochrome only applies to preview pane, not summaries)."""
+        return colored
+
+    def e(self, char: str) -> str:
+        """Return ASCII fallback if emoji_free mode is active (#315)."""
+        if self.emoji_free:
+            from .status_constants import EMOJI_ASCII
+            return EMOJI_ASCII.get(char, char)
+        return char
 
 
 # ---------------------------------------------------------------------------
@@ -251,7 +261,7 @@ def render_status_symbol(ctx: ColumnContext) -> ColumnOutput:
 
 def render_unvisited_alert(ctx: ColumnContext) -> ColumnOutput:
     if ctx.is_unvisited_stalled:
-        return [("🔔", ctx.mono(f"bold blink red{ctx.bg}", "bold"))]
+        return [(ctx.e("🔔"), ctx.mono(f"bold blink red{ctx.bg}", "bold"))]
     else:
         return [("  ", ctx.mono(f"dim{ctx.bg}", "dim"))]
 
@@ -278,7 +288,7 @@ def render_sleep_countdown(ctx: ColumnContext) -> ColumnOutput:
     """
     if ctx.sleep_wake_estimate is not None:
         remaining = max(0, (ctx.sleep_wake_estimate - datetime.now()).total_seconds())
-        return [(f" ⏰{format_duration(remaining):>5} ", ctx.mono(f"yellow{ctx.bg}", "bold"))]
+        return [(f" {ctx.e('⏰')}{format_duration(remaining):>5} ", ctx.mono(f"yellow{ctx.bg}", "bold"))]
     return None
 
 
@@ -440,21 +450,21 @@ render_median_work_time = _make_simple_render("median_work", format_duration, "
 def render_subagent_count(ctx: ColumnContext) -> ColumnOutput:
     count = ctx.live_subagent_count
     style = ctx.mono(f"bold purple{ctx.bg}", "bold") if count > 0 else ctx.mono(f"dim{ctx.bg}", "dim")
-    return [(f" 🤿{count:>2}", style)]
+    return [(f" {ctx.e('🤿')}{count:>2}", style)]
 
 
 def render_bash_count(ctx: ColumnContext) -> ColumnOutput:
     count = ctx.background_bash_count
     style = ctx.mono(f"bold yellow{ctx.bg}", "bold") if count > 0 else ctx.mono(f"dim{ctx.bg}", "dim")
-    return [(f" 🐚{count:>2}", style)]
+    return [(f" {ctx.e('🐚')}{count:>2}", style)]
 
 
 def render_child_count(ctx: ColumnContext) -> ColumnOutput:
     count = ctx.child_count
     if count == 0:
-        return [(" 👶 0", ctx.mono(f"dim{ctx.bg}", "dim"))]
+        return [(f" {ctx.e('👶')} 0", ctx.mono(f"dim{ctx.bg}", "dim"))]
     style = ctx.mono(f"bold cyan{ctx.bg}", "bold")
-    return [(f" 👶{count:>2}", style)]
+    return [(f" {ctx.e('👶')}{count:>2}", style)]
 
 
 render_permission_mode = _make_simple_render("perm_emoji", format_str=" {v}", colored_style="bold white")
@@ -462,7 +472,7 @@ render_permission_mode = _make_simple_render("perm_emoji", format_str=" {v}", co
 
 def render_agent_teams(ctx: ColumnContext) -> ColumnOutput:
     if ctx.session.agent_teams:
-        return [(" 🤝", ctx.mono(f"bold cyan{ctx.bg}", "bold"))]
+        return [(f" {ctx.e('🤝')}", ctx.mono(f"bold cyan{ctx.bg}", "bold"))]
     return None
 
 
@@ -473,7 +483,7 @@ def render_teams_plain(ctx: ColumnContext) -> Optional[str]:
 
 
 def render_allowed_tools(ctx: ColumnContext) -> ColumnOutput:
-    emojis = _tool_emojis(ctx.session.allowed_tools)
+    emojis = _tool_emojis(ctx.session.allowed_tools, emoji_free=ctx.emoji_free)
     if not emojis:
         return None
     return [(f" {emojis}", ctx.mono(f"white{ctx.bg}", ""))]
@@ -481,7 +491,7 @@ def render_allowed_tools(ctx: ColumnContext) -> ColumnOutput:
 
 def render_time_context(ctx: ColumnContext) -> ColumnOutput:
     if ctx.session.time_context_enabled:
-        return [(" 🕐", ctx.mono(f"bold white{ctx.bg}", "bold"))]
+        return [(f" {ctx.e('🕐')}", ctx.mono(f"bold white{ctx.bg}", "bold"))]
     else:
         return [("  ·", ctx.mono(f"dim{ctx.bg}", "dim"))]
 
@@ -489,24 +499,26 @@ def render_time_context(ctx: ColumnContext) -> ColumnOutput:
 def render_human_count(ctx: ColumnContext) -> ColumnOutput:
     if ctx.claude_stats is not None:
         human_count = max(0, ctx.claude_stats.interaction_count - ctx.stats.steers_count)
-        return [(f" 👤{human_count:>3}", ctx.mono(f"bold yellow{ctx.bg}", "bold"))]
+        return [(f" {ctx.e('👤')}{human_count:>3}", ctx.mono(f"bold yellow{ctx.bg}", "bold"))]
     else:
-        return [(" 👤  -", ctx.mono(f"dim yellow{ctx.bg}", "dim"))]
+        return [(f" {ctx.e('👤')}  -", ctx.mono(f"dim yellow{ctx.bg}", "dim"))]
 
 
-render_robot_count = _make_simple_render("stats.steers_count", format_str=" 🤖{v:>3}", colored_style="bold cyan")
+def render_robot_count(ctx: ColumnContext) -> ColumnOutput:
+    v = ctx.stats.steers_count
+    return [(f" {ctx.e('🤖')}{v:>3}", ctx.mono(f"bold cyan{ctx.bg}", "bold"))]
 
 
 def render_standing_orders(ctx: ColumnContext) -> ColumnOutput:
     s = ctx.session
     if s.standing_instructions:
         if s.standing_orders_complete:
-            return [(" ✓", ctx.mono(f"bold green{ctx.bg}", "bold"))]
+            return [(f" {ctx.e('✓')}", ctx.mono(f"bold green{ctx.bg}", "bold"))]
         elif s.standing_instructions_preset:
             preset_display = f" {s.standing_instructions_preset[:8]}"
             return [(preset_display, ctx.mono(f"bold cyan{ctx.bg}", "bold"))]
         else:
-            return [(" 📋", ctx.mono(f"bold yellow{ctx.bg}", "bold"))]
+            return [(f" {ctx.e('📋')}", ctx.mono(f"bold yellow{ctx.bg}", "bold"))]
     else:
         return [(" ➖", ctx.mono(f"bold dim{ctx.bg}", "dim"))]
 
@@ -525,24 +537,26 @@ def render_oversight_countdown(ctx: ColumnContext) -> ColumnOutput:
 
     deadline_str = ctx.oversight_deadline
     if not deadline_str:
-        return [(" ⏳ --:--", ctx.mono(f"yellow{ctx.bg}", "dim"))]
+        hg = ctx.e("⏳")
+        return [(f" {hg} --:--", ctx.mono(f"yellow{ctx.bg}", "dim"))]
 
     try:
+        hg = ctx.e("⏳")
         deadline = datetime.fromisoformat(deadline_str)
         remaining = (deadline - datetime.now()).total_seconds()
         if remaining <= 0:
-            return [(" ⏳ 0s  ", ctx.mono(f"bold blink red{ctx.bg}", "bold"))]
+            return [(f" {hg} 0s  ", ctx.mono(f"bold blink red{ctx.bg}", "bold"))]
 
         if remaining < 60:
-            text = f" ⏳ {remaining:>3.0f}s"
+            text = f" {hg} {remaining:>3.0f}s"
         elif remaining < 3600:
             mins = int(remaining // 60)
             secs = int(remaining % 60)
-            text = f" ⏳{mins:>2}m{secs:02d}s"
+            text = f" {hg}{mins:>2}m{secs:02d}s"
         else:
             hrs = int(remaining // 3600)
             mins = int((remaining % 3600) // 60)
-            text = f" ⏳{hrs:>2}h{mins:02d}m"
+            text = f" {hg}{hrs:>2}h{mins:02d}m"
 
         if remaining < 30:
             style = ctx.mono(f"bold blink red{ctx.bg}", "bold")
@@ -552,14 +566,15 @@ def render_oversight_countdown(ctx: ColumnContext) -> ColumnOutput:
             style = ctx.mono(f"bold yellow{ctx.bg}", "bold")
         return [(text, style)]
     except (ValueError, TypeError):
-        return [(" ⏳ --:--", ctx.mono(f"dim{ctx.bg}", "dim"))]
+        return [(f" {hg} --:--", ctx.mono(f"dim{ctx.bg}", "dim"))]
 
 
 def render_heartbeat(ctx: ColumnContext) -> ColumnOutput:
     s = ctx.session
+    hb = ctx.e("💓")
     if s.heartbeat_enabled and not s.heartbeat_paused:
         freq_str = format_duration(s.heartbeat_frequency_seconds)
-        segments = [(f" 💓{freq_str:>5}", ctx.mono(f"bold magenta{ctx.bg}", "bold"))]
+        segments = [(f" {hb}{freq_str:>5}", ctx.mono(f"bold magenta{ctx.bg}", "bold"))]
         # Next heartbeat time in 24hr format
         next_time_str = None
         if s.last_heartbeat_time:
@@ -584,24 +599,24 @@ def render_heartbeat(ctx: ColumnContext) -> ColumnOutput:
     elif s.heartbeat_enabled and s.heartbeat_paused:
         freq_str = format_duration(s.heartbeat_frequency_seconds)
         return [
-            (f" 💓{freq_str:>5}", ctx.mono(f"dim{ctx.bg}", "dim")),
+            (f" {hb}{freq_str:>5}", ctx.mono(f"dim{ctx.bg}", "dim")),
             ("     ⏸ ", ctx.mono(f"bold yellow{ctx.bg}", "bold")),
         ]
     else:
-        return [(" 💓    - @--:--", ctx.mono(f"dim{ctx.bg}", "dim"))]
+        return [(f" {hb}    - @--:--", ctx.mono(f"dim{ctx.bg}", "dim"))]
 
 
 def render_agent_value(ctx: ColumnContext) -> ColumnOutput:
     s = ctx.session
     if ctx.summary_detail in ("full", "high"):
-        return [(f" 💰{s.agent_value:>4}", ctx.mono(f"bold magenta{ctx.bg}", "bold"))]
+        return [(f" {ctx.e('💰')}{s.agent_value:>4}", ctx.mono(f"bold magenta{ctx.bg}", "bold"))]
     else:
         if s.agent_value > 1000:
-            return [(" ⏫️", ctx.mono(f"bold red{ctx.bg}", "bold"))]
+            return [(f" {ctx.e('⏫️')}", ctx.mono(f"bold red{ctx.bg}", "bold"))]
         elif s.agent_value < 1000:
-            return [(" ⏬️", ctx.mono(f"bold blue{ctx.bg}", "bold"))]
+            return [(f" {ctx.e('⏬️')}", ctx.mono(f"bold blue{ctx.bg}", "bold"))]
         else:
-            return [(" ⏹️ ", ctx.mono(f"dim{ctx.bg}", "dim"))]
+            return [(f" {ctx.e('⏹️')} ", ctx.mono(f"dim{ctx.bg}", "dim"))]
 
 
 # ---------------------------------------------------------------------------
@@ -901,14 +916,15 @@ def build_cli_context(
     any_has_budget: bool = False, child_count: int = 0, any_is_sleeping: bool = False,
     any_has_oversight_timeout: bool = False, oversight_deadline: Optional[str] = None,
     pr_number: Optional[int] = None, any_has_pr: bool = False,
-    monochrome: bool = True, summary_detail: str = "full",
+    monochrome: bool = True, emoji_free: bool = False, summary_detail: str = "full",
     has_sisters: bool = False, local_hostname: str = "",
     max_name_width: int = 16, max_repo_width: int = 10,
     max_branch_width: int = 10, all_names_match_repos: bool = False,
     subtree_cost_usd: float = 0.0, any_has_subtree_cost: bool = False,
 ) -> ColumnContext:
     """Build a ColumnContext from CLI data (no TUI widget needed)."""
-    status_symbol, _ = get_status_symbol(status)
+    from .status_constants import emoji_or_ascii
+    status_symbol, _ = get_status_symbol(status, emoji_free=emoji_free)
     uptime = calculate_uptime(session.start_time) if session.start_time else "-"
     green_time, non_green_time, sleep_time = get_current_state_times(
         stats, is_asleep=session.is_asleep
@@ -917,11 +933,11 @@ def build_cli_context(
 
     # Permissiveness mode emoji
     if session.permissiveness_mode == "bypass":
-        perm_emoji = "🔥"
+        perm_emoji = emoji_or_ascii("🔥", emoji_free)
     elif session.permissiveness_mode == "permissive":
-        perm_emoji = "🏃"
+        perm_emoji = emoji_or_ascii("🏃", emoji_free)
     else:
-        perm_emoji = "👮"
+        perm_emoji = emoji_or_ascii("👮", emoji_free)
 
     # Parse state_since for time-in-state
     status_changed_at = None
@@ -947,6 +963,7 @@ def build_cli_context(
         status_color="bold",
         bg="",
         monochrome=monochrome,
+        emoji_free=emoji_free,
         summary_detail=summary_detail,
         show_cost=True,
         any_has_budget=any_has_budget,

{overcode-0.2.3 → overcode-0.2.5}/src/overcode/tmux_manager.py

@@ -146,6 +146,17 @@ class TmuxManager:
                     if rest:
                         pane.send_keys(rest, enter=False)
                         time.sleep(0.1)
+                elif keys.startswith('/') and len(keys) > 1:
+                    # Special handling for slash commands (#307)
+                    # Claude Code shows a command menu when / is typed;
+                    # send / separately so the menu has time to appear
+                    # before the rest of the command and Enter arrive.
+                    pane.send_keys('/', enter=False)
+                    time.sleep(0.3)
+                    rest = keys[1:]
+                    if rest:
+                        pane.send_keys(rest, enter=False)
+                        time.sleep(0.15)
                 else:
                     pane.send_keys(keys, enter=False)
                     # Small delay for Claude Code to process text