micro-cc 0.2.97__tar.gz → 0.2.99__tar.gz

{micro_cc-0.2.97/src/micro_cc.egg-info → micro_cc-0.2.99}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: micro-cc
-Version: 0.2.97
+Version: 0.2.99
 Summary: Harness that gives frontier models full system access — shell, filesystem, browser, MCP — running directly on the metal.
 Author: George Salapa
 License: MIT License

{micro_cc-0.2.97 → micro_cc-0.2.99}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "micro-cc"
-version = "0.2.97"
+version = "0.2.99"
 description = "Harness that gives frontier models full system access — shell, filesystem, browser, MCP — running directly on the metal."
 readme = "README.md"
 requires-python = ">=3.12"

{micro_cc-0.2.97 → micro_cc-0.2.99}/src/micro_cc/claude_loop_.py

@@ -492,6 +492,15 @@ whole conversation history, including compacted turns.
         if proc_info:
             status_sections.append(f"<process-status>\n{proc_info}\n</process-status>")
 
+        # Other live micro-cc TUIs on this machine (see session_ipc_.list_peers),
+        # so message_session_ has real target paths to use.
+        from micro_cc.utils.session_ipc_ import format_peers
+        peers = format_peers(project_dir)
+        if peers:
+            status_sections.append(
+                f"<peer-sessions>\nOther live micro-cc sessions — message with message_session_(target_project_dir=...); replies arrive as incoming turns (do not poll them with monitor_):\n{peers}\n</peer-sessions>"
+            )
+
         # Conversation summary from sliding window — old-format fallback
         # only. Once a checkpoint exists, its content already rides inside
         # trimmed_rest below as token_cutter's prepended stand-in, so

{micro_cc-0.2.97 → micro_cc-0.2.99}/src/micro_cc/start_headless_.py

@@ -66,7 +66,7 @@ def _register(caller_project_dir: str, project_dir: str) -> str | None:
     from micro_cc.utils.subagent_tracker_ import add_tracked, NameInUse, CapReached
     from micro_cc.utils.settings_store_ import max_subagents
     try:
-        add_tracked(caller_project_dir, project_dir, fresh=True, max_running=max_subagents())
+        add_tracked(caller_project_dir, project_dir, max_running=max_subagents())
     except (NameInUse, CapReached) as e:
         return str(e)
     except OSError:

{micro_cc-0.2.97 → micro_cc-0.2.99}/src/micro_cc/start_live_tui_.py

@@ -588,6 +588,8 @@ class MicroTui():
 
     async def _render_loop(self) -> None:
         while self._running:
+            if self.tui.autoscroll_tick():
+                self._dirty = True
             if self._dirty:
                 try:
                     self.tui.do_render()
@@ -779,32 +781,8 @@ class MicroTui():
                         self.action_scroll_messages_down()
                 return
             self.tui.handle_selection_mouse_event(mouse)
-            # Drag-to-scroll: handle_selection_mouse_event only ever grows
-            # the selection range, it never moves the viewport — so a drag
-            # toward either edge to reach content currently scrolled out of
-            # view did nothing (this was the actual "I cannot drag and
-            # scroll down" bug: there was no auto-scroll at all, not a
-            # broken one). Only fires on an actual drag-motion event
-            # (button & 32, not a release) with a selection in progress,
-            # same guard handle_selection_mouse_event itself uses — a
-            # mouse-move with no button held is button==0 with the 32 bit
-            # unset, this never fires for those. Only scrolls once per
-            # motion event (there's no periodic timer driving this while
-            # the mouse sits still at the edge), but the terminal keeps
-            # sending motion events as long as the mouse keeps moving, so
-            # holding the drag past the edge and continuing to move it
-            # scrolls continuously, same physical gesture as any other
-            # drag-to-scroll UI.
-            if (
-                mouse["button"] & 32
-                and not mouse["release"]
-                and self.tui.selection_press_active
-            ):
-                _EDGE = 1
-                if mouse["y"] <= _EDGE:
-                    self.action_scroll_messages_up(1)
-                elif mouse["y"] >= self.terminal.rows - 1 - _EDGE:
-                    self.action_scroll_messages_down(1)
+            # Drag auto-scroll lives in TuiAltScreen.autoscroll_tick (driven by
+            # _render_loop) — selection is in content rows, so it survives scrolling.
             # Click-to-expand: on release, if handle_selection_mouse_event
             # didn't end up forming a real selection (anchor == focus —
             # exactly the "press and release landed at the same
@@ -1154,6 +1132,7 @@ class MicroTui():
         settings_store_.edit_setting("dangerous", list(self._dangerous_tools))
         self._close_picker("_dangerous_picker_overlay")
         self._refresh_status()
+        self.set_focus(self.prompt)
 
     def _on_slash_picked(self, item: PickerItem) -> None:
         self._close_picker("_slash_picker_overlay")
@@ -2699,7 +2678,7 @@ class MicroTui():
         Excludes any pid that's also a tracked subagent's own process — a
         `microcc-headless <dir> &` backgrounded through bash_ is both a
         survivor bash_tool sees via _track_survivors AND self-registers with
-        subagent_tracker_ (see add_tracked's fresh=True path), so without
+        subagent_tracker_ (see add_tracked), so without
         this filter the exact same process shows up twice: once as a
         subagent glyph, once as a raw PID pill. The two widgets are meant to
         be mutually exclusive for that pid — #subagent-status wins since it
@@ -2857,8 +2836,8 @@ class MicroTui():
         a later tick can't fire it again. PAUSED/NEEDS_INPUT are non-terminal
         (see _SUBAGENT_TERMINAL_STATUSES) so they still wake boss once, but
         keep displaying/prune-ineligible afterward — the process already
-        exited but still expects a relaunch, and a relaunch's fresh=True
-        add_tracked call is what resets notified for the next checkpoint."""
+        exited but still expects a relaunch, and a relaunch's add_tracked
+        call is what resets notified for the next checkpoint."""
         from micro_cc.utils import subagent_tracker_
         from micro_cc.tools.monitor_ import poll_status, format_status_glyph
         from micro_cc.utils.inbox_store_ import peek_pending_count
@@ -2891,7 +2870,7 @@ class MicroTui():
                     # line for a process that's dead. Without this check an
                     # entry a user had boss `kill <pid>` stays displayed
                     # (and un-prunable) forever. Only fires once pid is on
-                    # the entry (see add_tracked's fresh=True path) — older
+                    # the entry (see add_tracked) — older
                     # entries from before that field existed just fall
                     # through unchanged, same as today.
                     pid = entry.get("pid")

{micro_cc-0.2.97 → micro_cc-0.2.99}/src/micro_cc/tools/message_session_.py

@@ -27,6 +27,9 @@ async def message_session_(
          checkpoint while it's running), even if that run starts well after
          this call returns.
 
+    Don't follow up with monitor_ — a live session's reply arrives as its
+    own incoming turn, and monitor_ is for headless subagents and PIDs only.
+
     Args:
         target_project_dir: absolute path of the target project — whatever
             it was launched with, e.g. `python start_.py /path/to/project`

{micro_cc-0.2.97 → micro_cc-0.2.99}/src/micro_cc/tools/monitor_.py

@@ -7,7 +7,7 @@ from rich.markup import escape as _markup_escape
 
 from micro_cc.utils.msg_store_ import load_msgs, _get_storage_dir
 from micro_cc.utils.inbox_store_ import peek_pending_count
-from micro_cc.utils.subagent_tracker_ import add_tracked, read_tracked
+from micro_cc.utils.subagent_tracker_ import read_tracked
 from micro_cc.utils.tokenization_simple import peek_token_stats
 from micro_cc.utils import status_marker
 from micro_cc.tools.bash_tool import list_background_processes, get_output_tail
@@ -16,15 +16,10 @@ from micro_cc.tools import monitor_schedule_ as sched
 
 _POLL_TAIL_BYTES = 8192
 
-# Mirrors subagent_tracker_'s own prune-eligible set (DONE/FAILED — the
-# statuses that make an entry a DEAD END, see subagent_tracker_.py's
-# _TERMINAL_STATUSES). Used below to stop the passive add_tracked call from
-# resurrecting an already-pruned entry: if get_subagent_status just told us
-# this project_dir is DONE/FAILED, there's nothing left to watch for — the
-# caller already has that answer in this call's own return string — so
-# there's no reason to (re)create a placeholder for the poller to track.
-# Duplicated rather than imported, same as screen_cmds_.py's own copy —
-# each answers a locally different question and happens to share values.
+# Mirrors subagent_tracker_'s prune-eligible set (DONE/FAILED — dead ends, see
+# subagent_tracker_.py's _TERMINAL_STATUSES). Duplicated rather than imported,
+# same as screen_cmds_.py's own copy — each answers a locally different
+# question and happens to share values.
 _DONE_STATUSES = {"DONE", "FAILED"}
 
 
@@ -335,7 +330,9 @@ async def monitor_(
     watches over either. Pick the action:
 
     action="check" — on-demand snapshot of one or more `targets`, mixed
-        freely: a subagent's project_dir (absolute path, exactly as passed
+        freely (headless subagents and PIDs only — NOT for a live session you
+        messaged with message_session_; its delivery result is the answer, a
+        reply arrives as its own turn): a subagent's project_dir (absolute path, exactly as passed
         to microcc-headless) reports DONE/FAILED/PAUSED/NEEDS_INPUT (or "no
         output yet") plus its one-line summary and unread message_session_
         mail count; while it's running, also an activity line — pid alive or
@@ -422,8 +419,6 @@ async def monitor_(
                 lines.append(_format_bgproc_line(int(target.strip())))
             else:
                 info = get_subagent_status(target, caller_project_dir=project_dir)
-                if info["status"] not in _DONE_STATUSES:
-                    add_tracked(project_dir, info["resolved"])
                 lines.append(format_status_line(info))
         return "\n".join(lines)
 

{micro_cc-0.2.97 → micro_cc-0.2.99}/src/micro_cc/tui_native/alt_screen_.py

@@ -414,13 +414,11 @@ class OverlayHandle:
 # applySelectionHighlight, getWordSelection, getLineSelection, plus the
 # button-press/drag/release state machine (handleSelectionMouseEvent).
 #
-# Selection reads/writes directly against the composited screen
-# (self.previous_screen), bounded by terminal rows/columns. It does not
-# select inside a ScrollView's off-screen content that's scrolled out of
-# view — only what's currently painted. Needed to go further: routing a
-# selection point to the specific ScrollView under the cursor and reading
-# its full (not just visible) content, which needs each ScrollView's
-# on-screen rectangle known ahead of time, not just a flat list of lines.
+# A press outside the primary ScrollView selects against the composited
+# screen (self.previous_screen) in screen rows. A press inside it selects in
+# CONTENT rows (scroll_top + row-in-viewport), so the range survives
+# scrolling (wheel or drag auto-scroll) and copy reads the full content, not
+# just the painted window.
 _WORD_RE = re.compile(r"\w+|[^\w\s]+|\s+", re.UNICODE)
 
 
@@ -474,6 +472,11 @@ class TuiAltScreen:
         self.selection_initial_range: tuple[SelectionPoint, SelectionPoint] | None = None
         self.selection_press_active = False
         self._last_click: ClickTarget | None = None
+        self.selection_in_content = False   # points are content rows of primary_scroll_view
+        self.drag_edge = 0                  # -1/0/1: drag is parked at top/bottom edge of the viewport
+        self._drag_x = 0
+        self._last_autoscroll = 0.0
+        self._content_cache: list[str] | None = None
 
         # The scroll view search highlighting/navigation operates on.
         # Whoever builds the actual widget tree hands this in explicitly
@@ -612,8 +615,47 @@ class TuiAltScreen:
         return result
 
     # --- selection: text lookups over the last composited screen ------
+    def _scroll_region(self):
+        """(scroll_view, screen_offset, viewport_height) of the primary scroll view, or None."""
+        sv = self.primary_scroll_view
+        if sv is None or not hasattr(self.root, "find_offset"):
+            return None
+        offset = self.root.find_offset(sv)
+        if offset is None or sv.viewport_height <= 0:
+            return None
+        return sv, offset, sv.viewport_height
+
+    def _content_lines(self) -> list[str]:
+        if self._content_cache is None:
+            self._content_cache = [
+                strip_osc133_zone(l) for l in self.primary_scroll_view.child.render(self._terminal_size()[0])
+            ]
+        return self._content_cache
+
     def _selection_source_line(self, row: int) -> str:
-        return self.previous_screen[row] if 0 <= row < len(self.previous_screen) else ""
+        lines = self._content_lines() if self.selection_in_content else self.previous_screen
+        return lines[row] if 0 <= row < len(lines) else ""
+
+    def autoscroll_tick(self) -> bool:
+        """Called every frame by the app's render loop: while a drag is parked
+        on the viewport's top/bottom edge, scroll one line and extend the
+        selection to the newly revealed edge row (motion events stop when the
+        mouse sits still, so this can't be event-driven). True if it scrolled."""
+        if not (self.selection_press_active and self.selection_in_content and self.drag_edge):
+            return False
+        now = _time.monotonic()
+        if now - self._last_autoscroll < 0.04:
+            return False
+        region = self._scroll_region()
+        if region is None:
+            return False
+        sv, offset, height = region
+        if sv.scroll_by(self.drag_edge) == self.drag_edge:
+            return False  # already at the end of the content
+        self._last_autoscroll = now
+        edge_row = offset if self.drag_edge < 0 else offset + height - 1
+        self._update_selection_focus(SelectionPoint(edge_row - offset + sv.scroll_top, self._drag_x))
+        return True
 
     def _word_selection(self, point: SelectionPoint) -> tuple[SelectionPoint, SelectionPoint] | None:
         line = strip_terminal_sequences(self._selection_source_line(point.row))
@@ -702,8 +744,17 @@ class TuiAltScreen:
         if not sel:
             return screen
         start, end = sel
+        region = self._scroll_region() if self.selection_in_content else None
+        if self.selection_in_content and region is None:
+            return screen
 
-        def transform(row: int, line: str) -> str:
+        def transform(screen_row: int, line: str) -> str:
+            row = screen_row
+            if region:
+                sv, offset, height = region
+                if not offset <= screen_row < offset + height:
+                    return line
+                row = screen_row - offset + sv.scroll_top
             if row < start.row or row > end.row:
                 return line
             col_start, col_end = self._selection_columns(line, row, sel)
@@ -782,6 +833,12 @@ class TuiAltScreen:
         button, x, y, kind = int(m.group(1)), int(m.group(2)) - 1, int(m.group(3)) - 1, m.group(4)
         return {"button": button, "x": x, "y": y, "release": kind == "m"}
 
+    def _content_point(self, region, point: SelectionPoint) -> SelectionPoint:
+        """Screen point -> content-row point, clamped into the viewport."""
+        sv, offset, height = region
+        screen_row = max(offset, min(offset + height - 1, point.row))
+        return SelectionPoint(screen_row - offset + sv.scroll_top, point.col)
+
     def handle_selection_mouse_event(self, event: dict) -> None:
         term_width, term_height = self._terminal_size()
         button = event["button"] & 3
@@ -791,10 +848,14 @@ class TuiAltScreen:
             row=max(0, min(term_height - 1, event["y"])),
             col=max(0, min(term_width - 1, event["x"])),
         )
+        region = self._scroll_region()
+        if self.selection_press_active and self.selection_in_content and region:
+            point = self._content_point(region, point)
         if event["release"]:
             if not self.selection_press_active:
                 return
             self.selection_press_active = False
+            self.drag_edge = 0
             if self.selection_anchor is None:
                 return
             self._update_selection_focus(point)
@@ -804,10 +865,20 @@ class TuiAltScreen:
             if not self.selection_press_active or self.selection_anchor is None:
                 return
             self._last_click = None
+            if self.selection_in_content and region:
+                sv, offset, height = region
+                self._drag_x = point.col
+                self.drag_edge = -1 if event["y"] <= offset else (1 if event["y"] >= offset + height - 1 else 0)
             self._update_selection_focus(point)
             return
         # fresh press
         self.selection_press_active = True
+        self.drag_edge = 0
+        self.selection_in_content = bool(
+            region and region[1] <= point.row < region[1] + region[2] and not self.has_overlay()
+        )
+        if self.selection_in_content:
+            point = self._content_point(region, point)
         word = self._word_selection(point)
         click_count = self._get_click_count(point, word)
         rng = word if click_count == 2 else (self._line_selection(point) if click_count == 3 else None)
@@ -831,6 +902,7 @@ class TuiAltScreen:
     def do_render(self) -> None:
         width, height = self._terminal_size()
         width, height = max(1, width), max(1, height)
+        self._content_cache = None
 
         layout_lines = render_layout_frame(self.root, width, height)
         screen = [strip_osc133_zone(line) for line in layout_lines]

{micro_cc-0.2.97 → micro_cc-0.2.99}/src/micro_cc/utils/session_ipc_.py

@@ -11,6 +11,8 @@ feature this mirrors.
 
 import asyncio
 import json
+import os
+import time
 from pathlib import Path
 
 from micro_cc.utils.msg_store_ import _get_storage_dir
@@ -18,6 +20,45 @@ from micro_cc.utils.msg_store_ import _get_storage_dir
 _SEND_TIMEOUT = 3.0
 
 
+def _registry_dir() -> Path:
+    return Path.home() / ".micro-cc" / "sessions"
+
+
+def _pid_alive(pid: int) -> bool:
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    return True
+
+
+def list_peers(exclude_project_dir: str | None = None) -> list[dict]:
+    """Live TUI sessions registered in ~/.micro-cc/sessions/<pid>.json (what
+    start_listener writes), minus `exclude_project_dir` (the caller). Entries
+    whose pid is dead or whose socket is gone are swept."""
+    me = os.path.abspath(os.path.expanduser(exclude_project_dir)) if exclude_project_dir else None
+    peers = []
+    for f in _registry_dir().glob("*.json"):
+        try:
+            info = json.loads(f.read_text())
+            pid, pd = int(info["pid"]), info["project_dir"]
+        except (OSError, ValueError, KeyError, TypeError):
+            continue
+        if not _pid_alive(pid) or not socket_path(pd).exists():
+            f.unlink(missing_ok=True)
+            continue
+        if pd != me:
+            peers.append(info)
+    return sorted(peers, key=lambda i: i.get("started_at", 0))
+
+
+def format_peers(exclude_project_dir: str | None = None) -> str:
+    """One line per peer, for the per-loop status reminder; "" if none."""
+    return "\n".join(f"- {p['project_dir']} (pid {p['pid']})" for p in list_peers(exclude_project_dir))
+
+
 def socket_path(project_dir: str) -> Path:
     return _get_storage_dir(project_dir) / "session.sock"
 
@@ -36,6 +77,15 @@ async def start_listener(project_dir: str, on_message):
     path = socket_path(project_dir)
     if path.exists():
         path.unlink()
+    try:
+        _registry_dir().mkdir(parents=True, exist_ok=True)
+        (_registry_dir() / f"{os.getpid()}.json").write_text(json.dumps({
+            "pid": os.getpid(),
+            "project_dir": os.path.abspath(os.path.expanduser(project_dir)),
+            "started_at": time.time(),
+        }))
+    except OSError:
+        pass  # discovery is best-effort; messaging by explicit path still works
 
     async def handle(reader, writer):
         try:
@@ -54,6 +104,7 @@ async def start_listener(project_dir: str, on_message):
 
 def stop_listener(project_dir: str, server) -> None:
     server.close()
+    (_registry_dir() / f"{os.getpid()}.json").unlink(missing_ok=True)
     path = socket_path(project_dir)
     if path.exists():
         path.unlink()

{micro_cc-0.2.97 → micro_cc-0.2.99}/src/micro_cc/utils/subagent_tracker_.py

@@ -13,10 +13,10 @@ from list membership:
   3. When do we free the entry? — `prune`, a fully separate, low-stakes pass
      that only ever touches entries where (1) and (2) are already resolved.
 
-Populated two ways, both additive:
-  - start_headless_.py's self-registration on process startup
-    (`add_tracked(..., fresh=True)`), off MICROCC_CALLER_PROJECT_DIR.
-  - monitor_'s passive check-in (`add_tracked(..., fresh=False)`).
+Populated only by start_headless_.py's self-registration on process startup
+(`add_tracked`), off MICROCC_CALLER_PROJECT_DIR — which bash_ stamps on every
+subprocess, so a boss-spawned run always registers itself. monitor_ is
+read-only: checking a dir never creates an entry.
 
 This is what survives both /clear (a different file, untouched by
 cmd_clear's erase_msgs/erase_summary/clear_todos) and a full microcc
@@ -103,7 +103,7 @@ _TERMINAL_STATUSES = {"DONE", "FAILED"}
 
 
 class NameInUse(Exception):
-    """add_tracked(fresh=True) refused: `subagent_project_dir` already has a live
+    """add_tracked refused: `subagent_project_dir` already has a live
     RUNNING run. Without this, two concurrent microcc-headless invocations against
     the same project_dir would silently share one tracker entry AND one
     messages.jsonl conversation history — a real corruption risk, not just a
@@ -111,7 +111,7 @@ class NameInUse(Exception):
 
 
 class CapReached(Exception):
-    """add_tracked(fresh=True, max_running=N) refused: N other subagents of this
+    """add_tracked(max_running=N) refused: N other subagents of this
     boss are already live. Checked under the same flock as the write, so N
     simultaneous spawns can't all read "N-1 running" and all register."""
 
@@ -127,14 +127,14 @@ def _pid_alive(pid) -> bool:
 
 
 def add_tracked(
-    caller_project_dir: str, subagent_project_dir: str, *, fresh: bool = False,
+    caller_project_dir: str, subagent_project_dir: str, *,
     max_running: int | None = None,
 ) -> None:
-    """fresh=True is start_headless_.py's self-registration — a
-    microcc-headless process announcing "I am starting a run right now,"
-    including a legitimate relaunch of a project_dir that already finished
-    once before. (Over)writes a brand-new RUNNING/not-notified entry, which
-    is what lets a relaunch notify again on its second completion — UNLESS
+    """start_headless_.py's self-registration — a microcc-headless process
+    announcing "I am starting a run right now," including a legitimate
+    relaunch of a project_dir that already finished once before.
+    (Over)writes a brand-new RUNNING/not-notified entry, which is what lets a
+    relaunch notify again on its second completion — UNLESS
     `subagent_project_dir` is currently claimed by another still-alive
     RUNNING process, in which case this raises NameInUse instead of
     silently clobbering it. The liveness check and the write happen under
@@ -143,29 +143,13 @@ def add_tracked(
     entry (dead pid — crashed without ever updating status) is still safely
     reclaimed.
 
-    fresh=False (the default) is monitor_'s passive "check on
-    this" call — no run is starting, so it only inserts a placeholder entry
-    if the key is entirely absent; if the key is already present, this is a
-    no-op. This function alone can't tell "genuinely never tracked" apart
-    from "was tracked, finished, and already got pruned" — both look like
-    "key absent" from here, and inserting a RUNNING/no-pid placeholder for
-    the latter is a real bug: that placeholder never gets a pid (only
-    fresh=True sets one), so the poller's pid-liveness self-heal
-    (start_live_.py's _poll_subagents_tick) can never clear it, and it sits
-    on the status line forever, unnotified. The guard against that lives on
-    the caller's side instead — monitor_ only calls this when the
-    status it just read for subagent_project_dir isn't already DONE/FAILED,
-    since a call that already knows the terminal answer has nothing left to
-    watch for. Don't drop that caller-side check without replacing it.
-
-    max_running (fresh=True only): refuse with CapReached if that many OTHER
-    subagents of this boss are live — same flock as the NameInUse check.
-    Placeholder entries (monitor_'s passive check-in, no pid) don't count.
+    max_running: refuse with CapReached if that many OTHER subagents of this
+    boss are live — same flock as the NameInUse check.
     """
     def _do():
         data = _read(caller_project_dir)
         subagents = data["subagents"]
-        if fresh and max_running is not None:
+        if max_running is not None:
             running = [
                 pd for pd, e in subagents.items()
                 if pd != subagent_project_dir and e.get("status") == "RUNNING"
@@ -178,37 +162,31 @@ def add_tracked(
                     f"{max_running} (the user can change it with /subagents). Wait for one to "
                     f"finish (you get a checkpoint wakeup), or stop one, then spawn again."
                 )
-        if fresh:
-            existing = subagents.get(subagent_project_dir)
-            if existing and existing.get("status") == "RUNNING" and existing.get("pid") is not None:
-                try:
-                    os.kill(existing["pid"], 0)
-                except ProcessLookupError:
-                    pass  # stale entry (crashed without updating status) — safe to reclaim
-                else:
-                    raise NameInUse(
-                        f"'{subagent_project_dir}' already has a run in progress "
-                        f"(pid {existing['pid']}) — wait for it to finish, or check "
-                        f"monitor_ before relaunching."
-                    )
-            subagents[subagent_project_dir] = {
-                "status": "RUNNING", "notified": False, "updated_at": time.time(),
-                # This runs inside the microcc-headless process itself (see
-                # start_headless_.py's run_headless), so os.getpid() here IS
-                # the subagent for its whole lifetime — lets the ambient
-                # poller (start_live_.py's _poll_subagents_tick) tell "still
-                # actually running" apart from "killed/crashed before ever
-                # writing a terminal STATUS line," which would otherwise
-                # leave the entry stuck RUNNING forever (nothing else ever
-                # updates status for a process that's dead).
-                "pid": os.getpid(),
-            }
-            _write(caller_project_dir, data)
-        elif subagent_project_dir not in subagents:
-            subagents[subagent_project_dir] = {
-                "status": "RUNNING", "notified": False, "updated_at": time.time(),
-            }
-            _write(caller_project_dir, data)
+        existing = subagents.get(subagent_project_dir)
+        if existing and existing.get("status") == "RUNNING" and existing.get("pid") is not None:
+            try:
+                os.kill(existing["pid"], 0)
+            except ProcessLookupError:
+                pass  # stale entry (crashed without updating status) — safe to reclaim
+            else:
+                raise NameInUse(
+                    f"'{subagent_project_dir}' already has a run in progress "
+                    f"(pid {existing['pid']}) — wait for it to finish, or check "
+                    f"monitor_ before relaunching."
+                )
+        subagents[subagent_project_dir] = {
+            "status": "RUNNING", "notified": False, "updated_at": time.time(),
+            # This runs inside the microcc-headless process itself (see
+            # start_headless_.py's run_headless), so os.getpid() here IS
+            # the subagent for its whole lifetime — lets the ambient
+            # poller (start_live_.py's _poll_subagents_tick) tell "still
+            # actually running" apart from "killed/crashed before ever
+            # writing a terminal STATUS line," which would otherwise
+            # leave the entry stuck RUNNING forever (nothing else ever
+            # updates status for a process that's dead).
+            "pid": os.getpid(),
+        }
+        _write(caller_project_dir, data)
     _with_lock(caller_project_dir, _do)
 
 

{micro_cc-0.2.97 → micro_cc-0.2.99/src/micro_cc.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: micro-cc
-Version: 0.2.97
+Version: 0.2.99
 Summary: Harness that gives frontier models full system access — shell, filesystem, browser, MCP — running directly on the metal.
 Author: George Salapa
 License: MIT License

{micro_cc-0.2.97 → micro_cc-0.2.99}/tests/test_subagent_lifecycle.py

@@ -196,9 +196,9 @@ class CapTests(unittest.TestCase):
             "/x/placeholder": {"status": "RUNNING", "notified": False},
             "/x/done": {"status": "DONE", "notified": True, "pid": os.getpid()},
         }}))
-        tracker.add_tracked(boss, "/x/new1", fresh=True, max_running=2)  # 1 live other -> ok
+        tracker.add_tracked(boss, "/x/new1", max_running=2)  # 1 live other -> ok
         with self.assertRaises(tracker.CapReached) as cm:
-            tracker.add_tracked(boss, "/x/new2", fresh=True, max_running=2)
+            tracker.add_tracked(boss, "/x/new2", max_running=2)
         self.assertIn("limit is 2", str(cm.exception))
 
     def test_cap_holds_under_simultaneous_registration_by_real_processes(self):
@@ -208,7 +208,7 @@ class CapTests(unittest.TestCase):
             "import os,sys,time\n"
             "from micro_cc.utils import subagent_tracker_ as t\n"
             "try:\n"
-            f"    t.add_tracked({boss!r}, sys.argv[1], fresh=True, max_running=2); print('OK', flush=True)\n"
+            f"    t.add_tracked({boss!r}, sys.argv[1], max_running=2); print('OK', flush=True)\n"
             "except t.CapReached: print('CAP', flush=True)\n"
             f"while not os.path.exists({release!r}): time.sleep(0.05)\n"
         )
@@ -339,7 +339,7 @@ class DetachedSpawnTests(unittest.TestCase):
         settings_store_.edit_setting("max_subagents", 1)
         holder = subprocess.Popen([sys.executable, "-c", "import time; time.sleep(60)"])
         try:
-            tracker.add_tracked(self.boss, "/x/busy", fresh=True)
+            tracker.add_tracked(self.boss, "/x/busy")
             data = tracker.read_tracked(self.boss)
             data["subagents"]["/x/busy"]["pid"] = holder.pid
             (_get_storage_dir(self.boss) / "tracked_subagents.json").write_text(json.dumps(data))