micro-cc 0.2.76__tar.gz → 0.2.78__tar.gz

{micro_cc-0.2.76/src/micro_cc.egg-info → micro_cc-0.2.78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: micro-cc
-Version: 0.2.76
+Version: 0.2.78
 Summary: Harness that gives frontier models full system access — shell, filesystem, browser, MCP — running directly on the metal.
 Author: George Salapa
 License: Copyright (c) 2026 George Salapa. All rights reserved.

{micro_cc-0.2.76 → micro_cc-0.2.78}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "micro-cc"
-version = "0.2.76"
+version = "0.2.78"
 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.76 → micro_cc-0.2.78}/src/micro_cc/claude_loop_.py

@@ -128,6 +128,13 @@ async def claude_loop(
     skills_summary = get_skill_summary(project_dir)
     claude_md_content = load_claude_md_file(project_dir)
     mcp_catalog = get_effective_mcp_catalog(project_dir)
+    # Where micro_cc's OWN source lives on disk — never project_dir (the
+    # user's project) and never wherever a skill file happens to live. This
+    # file (claude_loop_.py) sits directly in the package dir, so its own
+    # dirname IS that resolved path, editable checkout or real pip install
+    # alike — same fact graph-orchestration/SKILL.md has the model resolve
+    # itself via `import micro_cc, os; os.path.dirname(micro_cc.__file__)`.
+    package_dir = os.path.dirname(os.path.abspath(__file__))
 
     # Core tools: bash, file ops, search, planning, skills
     default_tools = [
@@ -233,6 +240,7 @@ async def claude_loop(
 - You are running LOCALLY on the user's machine (on the metal), NOT a remote server
 - You have direct access to the local filesystem, Desktop, Documents, etc.
 - Project directory: {project_dir}
+- Your own source code lives at: {package_dir} (not project_dir)
 - Date: {datetime.datetime.now().strftime("%B %d, %Y")}
 
 ## Core Tools (always available)
@@ -252,25 +260,16 @@ message_session_ (message another live micro-cc session), etc.
 - todo_tool_: For multi-step complex work, write a todo plan and keep on track.
 
 ## Long-term Memory
-use memory_ (action=add|edit|get|delete|list, scope=global|project): two
-independent key spaces. scope="global" (default) persists across ALL
-projects and sessions, stored at ~/.micro-cc/memory.json — use for durable
-facts that hold regardless of project: user preferences, standing
-decisions, cross-project gotchas, references. scope="project" persists only
-for this project_dir, stored under
-~/.micro-cc/projects/{{name}}_{{hash}}/memory.json — use for durable facts
-specific to this project (conventions, decisions, recurring gotchas) that
-are worth recalling next time you're invoked here. A manifest of
-keys+descriptions for both scopes is injected into your context each loop
-as <memory-manifest> — use memory_(action="get", key=..., scope=...) to
-expand an entry. For merely in-progress state within the current session,
-use todo_tool_ or the project's own files instead.
+memory_ (action=add|edit|get|delete|list, scope=global|project).
+scope="global": cross-project facts (~/.micro-cc/memory.json). scope="project":
+this project only (~/.micro-cc/projects/{{name}}_{{hash}}/memory.json).
+<memory-manifest> lists keys each loop; memory_(action="get", key=...) expands
+one. In-progress state: use todo_tool_ instead.
 
 ## Conversation History Search
-search_history_(query=..., limit=...): full-text search over this
-project's ENTIRE conversation history, including turns already folded out
-of your live context by checkpoint compaction — nothing folded is ever
-actually deleted.
+conversation grows forever
+search_history_(query=..., limit=...): full-text search over this project's
+whole conversation history, including compacted turns.
 
 {skills_summary}
 {claude_md_section}
@@ -278,6 +277,7 @@ actually deleted.
 ## Guidelines
 - Read files before editing them
 - Use absolute paths when working outside project_dir
+- When writing to user, remove all mannered prose
 """,
         # stable prefix -> cache tools + this system prompt. Content is
         # byte-identical across loop iterations of this same call (built
@@ -316,6 +316,61 @@ actually deleted.
         """
     msgs.append({"role": "user", "content": content})
 
+    def _build_memory_manifest() -> str | None:
+        """Key+description index of both memory scopes (see memory_tool_'s
+        docstring) — None if both are empty. Cheap: list_memories() is one
+        small JSON read per scope, no directory walk."""
+        parts = []
+        global_items = memory_store_.list_memories()
+        if global_items:
+            parts.append(
+                "Global (all projects):\n"
+                + "\n".join(f"- {it['key']} — {it['description']}" for it in global_items)
+            )
+        project_items = memory_store_.list_memories(project_dir=project_dir)
+        if project_items:
+            parts.append(
+                "Project (this project_dir only):\n"
+                + "\n".join(f"- {it['key']} — {it['description']}" for it in project_items)
+            )
+        return "\n\n".join(parts) if parts else None
+
+    # Memory manifest rides as its OWN role:"system" block, right after
+    # system_prompt_msg — not folded into it, so it gets its own independent
+    # cache_control breakpoint (anthropic.py/litellm.py/foundry.py all
+    # already support N system messages, each optionally cache_control'd —
+    # see their system_prompts-block handling). Built once here, frozen for
+    # every internal loop iteration of THIS turn, same timing as
+    # system_prompt_msg itself: memory changes are rare relative to loop
+    # iterations, so this block matches system_prompt_msg's own cache
+    # profile (byte-identical turn to turn in the common case -> cache hit
+    # on this block too) instead of eating a rolling-breakpoint miss on
+    # every single tool round-trip the way a tail-appended manifest would.
+    # A turn where memory actually changed since the last turn pays a
+    # one-time miss on THIS block only — the system_prompt_msg breakpoint
+    # and the separate rolling transcript breakpoint are untouched, so nei-
+    # ther your tools+system-prompt cache nor your accumulated transcript
+    # cache gets invalidated by a memory edit.
+    _memory_manifest_baseline = _build_memory_manifest()
+    memory_manifest_msg = (
+        {
+            "role": "system",
+            "content": f"## Long-term Memory\nKey+description index for both scopes — call memory_(action=\"get\", key=..., scope=...) to expand an entry.\n\n{_memory_manifest_baseline}",
+            "cache_control": {"type": "ephemeral"},
+        }
+        if _memory_manifest_baseline is not None
+        else None
+    )
+    # Mid-turn notify-once tracking for memory_ calls Claude makes DURING
+    # this turn's own tool loop: the block above is frozen for the whole
+    # turn (see comment above), so a mid-turn add/edit/delete can't safely
+    # update it without eating the miss on every remaining iteration of
+    # this turn. Instead it surfaces as a cheap tail delta (see below),
+    # gated the same notify-once way format_background_status and
+    # subagent_tracker_ already are — shown once when it first diverges
+    # from the frozen baseline, silent after, until it changes again.
+    _last_shown_manifest = _memory_manifest_baseline
+
     while True:
         checkpoint = load_checkpoint(project_dir)
         # If history is now shorter than as_of_index (e.g. /rewind cut
@@ -331,31 +386,26 @@ actually deleted.
         # takes effect starting next turn.
         asyncio.create_task(compact_checkpoint(project_dir, msgs, len(msgs), model))
 
-        # Dynamic per-loop status (file-changes/process-status/summary/memory).
-        # Collected as plain sections, then sent as ONE role:"user" message
-        # appended AFTER the transcript — never as role:"system", never
-        # prepended before it. Two reasons, both load-bearing (see TODO.md):
-        #   1. anthropic.py always pulls every role:"system" message into one
-        #      block that the API places before `messages`, regardless of
-        #      Python-list order — so a role:"system" prepend here sits
-        #      between the two cache breakpoints (system_prompt_msg's, and
-        #      the rolling one anthropic.py/litellm.py set on the last
-        #      stable transcript message) no matter where in the list it's
-        #      built. Since this content changes almost every turn once a
-        #      checkpoint summary is active, that busts the rolling
-        #      breakpoint's match on most turns, even though the actual old
-        #      transcript messages never changed.
-        #   2. Recency matters for the model too, not just for caching — the
-        #      freshest situational read (what changed since I last looked,
-        #      what's running now) belongs closest to the point where the
-        #      model has to act next, not buried ahead of the whole
-        #      conversation.
+        # Dynamic per-loop status (file-changes/process-status/summary, plus
+        # a memory delta — see below). Collected as plain sections, sent as
+        # ONE role:"user" message appended AFTER the transcript, flagged
+        # _ephemeral. This block changes on essentially every iteration
+        # (file writes, process starts/finishes, checkpoint summaries), so
+        # it stays out of any cache_control breakpoint on purpose — a
+        # role:"system" prepend for genuinely-every-iteration content would
+        # sit ahead of the rolling transcript breakpoint and bust it on
+        # most turns. The memory manifest doesn't belong to this category
+        # any more (see memory_manifest_msg above, built once per turn as
+        # its own cached role:"system" block) — what's built below for
+        # memory is only the rare mid-turn DELTA against that frozen
+        # baseline, which is exactly as volatile as file-changes/
+        # process-status and belongs in the same ephemeral tail bucket.
         # Wrapped in <system-reminder> — the same non-real-user-query marker
         # token_cutter's is_real_user_msg already recognizes — and flagged
-        # _ephemeral so anthropic.py/litellm.py's cache-breakpoint walk-back
-        # (which already exists for exactly this purpose — see both files'
-        # bp_idx logic) skips past it and anchors on the last REAL stable
-        # transcript message instead of on this ever-changing block.
+        # _ephemeral so anthropic.py/litellm.py/foundry.py's cache-breakpoint
+        # walk-back (see each file's bp_idx logic) skips past it and anchors
+        # on the last REAL stable transcript message instead of on this
+        # ever-changing block.
         status_sections = []
 
         # File changes — self-scoped to paths WE'VE read/written (see
@@ -384,27 +434,25 @@ actually deleted.
             if conversation_summary:
                 status_sections.append(f"<conversation-summary>\n{conversation_summary}\n</conversation-summary>")
 
-        # Long-term memory manifest — two scopes (see memory_tool_'s docstring):
-        # global (~/.micro-cc/memory.json, shared across ALL projects) and
-        # project (this project_dir's own ~/.micro-cc/projects/.../memory.json).
-        # Key+description only; call memory_(action="get", key=..., scope=...)
-        # to expand an entry's full content.
-        manifest_parts = []
-        global_memory_items = memory_store_.list_memories()
-        if global_memory_items:
-            manifest_parts.append(
-                "Global (all projects):\n"
-                + "\n".join(f"- {it['key']} — {it['description']}" for it in global_memory_items)
-            )
-        project_memory_items = memory_store_.list_memories(project_dir=project_dir)
-        if project_memory_items:
-            manifest_parts.append(
-                "Project (this project_dir only):\n"
-                + "\n".join(f"- {it['key']} — {it['description']}" for it in project_memory_items)
+        # Memory-manifest DELTA only — the manifest itself lives in
+        # memory_manifest_msg (role:"system", built once above, frozen for
+        # this whole turn so it can carry its own cache_control breakpoint).
+        # If Claude called memory_ mid-turn, that frozen block is now stale;
+        # rebuilding it here instead of just noting the diff would touch a
+        # role:"system" block mid-turn and cost every remaining iteration of
+        # this turn a cache miss on it. So: compare live state to the frozen
+        # baseline, and if it moved, say so once in the ephemeral tail
+        # (same notify-once contract as format_background_status/
+        # subagent_tracker_) — silent again once shown, until it moves
+        # again. Fully caught up again next turn, when a fresh
+        # memory_manifest_msg gets built from current state.
+        current_manifest = _build_memory_manifest()
+        if current_manifest is not None and current_manifest != _last_shown_manifest:
+            status_sections.append(
+                "<memory-manifest-update>\nMemory changed since this turn started "
+                f"(still call memory_(action=\"get\", ...) to expand an entry):\n\n{current_manifest}\n</memory-manifest-update>"
             )
-        if manifest_parts:
-            manifest = "\n\n".join(manifest_parts)
-            status_sections.append(f"<memory-manifest>\n{manifest}\n</memory-manifest>")
+            _last_shown_manifest = current_manifest
 
         status_msgs = []
         if status_sections:
@@ -414,15 +462,17 @@ actually deleted.
                 "_ephemeral": True,
             })
 
-        # Assemble: stable system prompt FIRST so the cached prefix (tools +
-        # system prompt) stays byte-identical across loops; the transcript
-        # follows so its own rolling breakpoint covers it; dynamic status
-        # goes LAST, after both cache anchors, never in front of content
-        # meant to be reused from cache. msgs itself never carries a system
-        # message (see system_prompt_msg above) — token_cutter still drops
-        # any role=="system" it finds in `rest` regardless, which is what
-        # self-heals a project whose messages.jsonl predates this and still
-        # has one stored in history.
+        # Assemble: system_prompt_msg then memory_manifest_msg — both
+        # role:"system", both frozen for this whole turn, each its own
+        # cache_control breakpoint — so the cached prefix stays byte-
+        # identical across loops in the common case; the transcript follows
+        # so its own rolling breakpoint covers it; dynamic status (incl. the
+        # memory delta) goes LAST, after every cache anchor, never in front
+        # of content meant to be reused from cache. msgs itself never
+        # carries a system message (see system_prompt_msg above) —
+        # token_cutter still drops any role=="system" it finds in `rest`
+        # regardless, which is what self-heals a project whose
+        # messages.jsonl predates this and still has one stored in history.
         if checkpoint:
             trimmed_rest = token_cutter(
                 msgs, max_tokens,
@@ -432,7 +482,12 @@ actually deleted.
             )
         else:
             trimmed_rest = token_cutter(msgs, max_tokens)
-        trimmed_loop_msgs = [system_prompt_msg] + trimmed_rest + status_msgs
+        trimmed_loop_msgs = (
+            [system_prompt_msg]
+            + ([memory_manifest_msg] if memory_manifest_msg else [])
+            + trimmed_rest
+            + status_msgs
+        )
 
         try:
             # Imported lazily, per-branch: anthropic/openai are the two

{micro_cc-0.2.76 → micro_cc-0.2.78}/src/micro_cc/models/litellm.py

@@ -360,15 +360,22 @@ def _msgs_to_responses(anthropic_msgs):
     reasoning each turn from the transcript; no signature/id replay needed
     for multi-turn tool calling to work.
     """
-    instructions = None
+    instructions_parts = []
     out = []
     for msg in anthropic_msgs:
         role = msg.get("role")
         content = msg.get("content", "")
 
         if role == "system":
-            if isinstance(content, str):
-                instructions = content
+            # Callers may send more than one system message now (e.g.
+            # claude_loop_'s system_prompt_msg + memory_manifest_msg, each
+            # its own cache_control-bearing block for the Anthropic-native
+            # path) — the Responses API has no such multi-block system
+            # concept, so join them into the one `instructions` string in
+            # message order instead of last-write-wins dropping everything
+            # but the last one.
+            if isinstance(content, str) and content:
+                instructions_parts.append(content)
             continue
 
         if role == "assistant" and isinstance(content, list):
@@ -439,7 +446,7 @@ def _msgs_to_responses(anthropic_msgs):
         # --- Simple string content (user/assistant plain turns) ---
         out.append({"role": role, "content": content})
 
-    return instructions, out
+    return ("\n\n".join(instructions_parts) if instructions_parts else None), out
 
 
 def _wrap_responses_output(resp):

{micro_cc-0.2.76 → micro_cc-0.2.78}/src/micro_cc/tools/bash_tool.py

@@ -251,10 +251,21 @@ async def _track_survivors(pgid: int, command: str, cwd: str, project_dir: str)
             "started_at": time.time(),
             "pgid": pgid,
             "output_path": str(out_path),
+            "notified": False,
         }
     return out_path if found else None
 
 
+# One-shot "this pid just finished" notices, queued by list_background_processes'
+# pruning below and drained by format_background_status. Mirrors
+# subagent_tracker_'s notified-flag pattern (see that module's docstring):
+# a still-running process is worth polling for on demand (monitor_/bash_
+# ps), a state CHANGE (started, finished) is worth pushing once. Plain
+# list, not keyed by pid, since a finished entry is removed from
+# _background_procs the same tick it's queued here — nothing to dedupe.
+_finished_procs: list[dict] = []
+
+
 def list_background_processes() -> list[dict]:
     """Prune exited processes and return survivors — the same self-scoped
     set format_background_status formats for the model, structured for a
@@ -263,7 +274,11 @@ def list_background_processes() -> list[dict]:
         try:
             os.kill(pid, 0)
         except ProcessLookupError:
-            del _background_procs[pid]
+            info = _background_procs.pop(pid)
+            _finished_procs.append({
+                "pid": pid, "command": info["command"], "cwd": info["cwd"],
+                "output_path": info["output_path"],
+            })
     # A pgid's drain tasks (see _drain_to_file) outlive any one child pid
     # entry — only cancel them once nothing left in _background_procs still
     # points at that pgid, i.e. every pid ps -g ever found there is gone.
@@ -306,14 +321,32 @@ def get_output_tail(pid: int, max_chars: int = 2000) -> str | None:
 
 
 def format_background_status() -> str | None:
-    """Format survivors for the per-loop reminder."""
-    procs = list_background_processes()
-    if not procs:
+    """Format state CHANGES for the per-loop reminder — same notify-once
+    contract as subagent_tracker_ (see that module's docstring: still-alive
+    is worth showing once, up front; after that it's pull-on-demand via
+    monitor_/bash_, not a repeated per-loop restatement). Concretely:
+    - a newly-tracked pid gets exactly one "started" line, right after
+      list_background_processes() has already pruned/queued any finished
+      ones for this same call, so the notified flag flips only for pids
+      that are still genuinely alive this tick.
+    - a pid that died since the last check gets exactly one "finished" line,
+      drained from _finished_procs and not re-shown.
+    An already-notified, still-running pid is silent here — the model was
+    told once it exists and can check on it itself; no per-iteration nag.
+    """
+    procs = list_background_processes()  # prunes dead pids into _finished_procs first
+    lines = []
+    if _finished_procs:
+        for f in _finished_procs:
+            lines.append(f"  PID {f['pid']} finished: {f['command']}  (cwd={f['cwd']}) — output was captured to {f['output_path']}, read it if you need to check what happened")
+        _finished_procs.clear()
+    new_procs = [p for p in procs if not _background_procs[p["pid"]]["notified"]]
+    for p in new_procs:
+        lines.append(f"  PID {p['pid']} started: {p['command']}  (cwd={p['cwd']}) — stop with bash_(\"kill {p['pid']}\"), check output with monitor_([\"{p['pid']}\"])")
+        _background_procs[p["pid"]]["notified"] = True
+    if not lines:
         return None
-    lines = ["Processes still running in the background (started via bash_):"]
-    for p in procs:
-        lines.append(f"  PID {p['pid']}: {p['command']}  (cwd={p['cwd']}, running {p['age']}s) — stop with bash_(\"kill {p['pid']}\"), check output with monitor_([\"{p['pid']}\"])")
-    return "\n".join(lines)
+    return "Background process update:\n" + "\n".join(lines)
 
 
 def _kill_tree(proc):

{micro_cc-0.2.76 → micro_cc-0.2.78}/src/micro_cc/tui_native/etype_handler_.py

@@ -80,7 +80,7 @@ async def handle_tool_result(app, event, container, tool_call_rows, approval_row
 # delta finishes trickling out — the pacing throttles the source, so there's
 # never a backlog to burst-flush later (see StreamingRow's docstring).
 _FRAME = 0.012
-_CHARS_PER_TICK = 3
+_CHARS_PER_TICK = 6
 
 
 async def _stream_delta(app, event, container, mode):

{micro_cc-0.2.76 → micro_cc-0.2.78/src/micro_cc.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: micro-cc
-Version: 0.2.76
+Version: 0.2.78
 Summary: Harness that gives frontier models full system access — shell, filesystem, browser, MCP — running directly on the metal.
 Author: George Salapa
 License: Copyright (c) 2026 George Salapa. All rights reserved.