@andespindola/crow-skills 0.18.2 → 0.19.1

package/crow_skills/__init__.py

@@ -1,3 +1,3 @@
 """Portable, local-first installer for the crow-skills catalogue."""
 
-__version__ = "0.18.2"
+__version__ = "0.19.1"

package/crow_skills/broadcast.py

@@ -352,6 +352,14 @@ def edit_paths(host, tool, tool_input, cwd):
 GIT_WORD = re.compile(r"^(?:\S*/)?git$")
 DIR_WORD = re.compile(r"(?:^|[\s;&|()])(?:cd|[^\s;&|()]*/?git)(?:\s|$)")
 TREE_SUBCOMMANDS = ("checkout", "switch", "rebase", "stash", "merge", "pull", "cherry-pick", "bisect", "restore", "clean")
+# A git call is not by itself a sign of working in a clone: `git log`, `git status` and `git diff`
+# are reading. Measured right after shipping occupancy(): a peer session that only INSPECTED two
+# clones was still published as occupying them, because any git verb marked the clone as driven.
+# Everything outside this list keeps marking occupancy, so an unknown verb errs toward warning.
+READ_SUBCOMMANDS = ("log", "status", "diff", "show", "rev-parse", "rev-list", "ls-tree", "ls-files",
+                    "ls-remote", "cat-file", "describe", "blame", "shortlog", "for-each-ref",
+                    "name-rev", "merge-base", "symbolic-ref", "whatchanged", "grep", "count-objects",
+                    "check-ignore", "verify-commit", "verify-tag", "var", "help", "version")
 
 
 def tree_command(host, tool, tool_input, cwd=None):
@@ -423,7 +431,7 @@ def _note(visited, directory, source="cd"):
     if visited is None or not directory or not directory.startswith("/"):
         return
     if directory in visited:
-        if source == "git":
+        if source == "git":  # working outranks reading and the incidental cd
             visited[directory] = "git"
         return
     if len(visited) < MAX_PATTERNS:
@@ -488,7 +496,8 @@ def _segment(words, here, targets, depth=0, visited=None):
     if i >= len(words):
         return here
     sub, rest = words[i], words[i + 1:]
-    _note(visited, directory, "git")  # any git call names the clone the session is working in
+    # "git" means the session WORKS in that clone; a read-only verb means it only looked.
+    _note(visited, directory, "read" if sub in READ_SUBCOMMANDS else "git")
     if sub in TREE_SUBCOMMANDS or (sub == "reset" and "--hard" in rest):
         if directory and directory not in targets:
             targets.append(directory)
@@ -703,14 +712,21 @@ def fold(snap, event, touched=(), now=None, ppid=None, cli_pid=None, tty_runner=
         repos = [r for r in repos if r["root"] != found["root"]]
         entry = {"id": found["id"], "root": found["root"], "ts": now_iso(now),
                  "hits": int((previous or {}).get("hits") or 0) + 1}
-        if (previous or {}).get("driven") or (isinstance(dirs, dict) and dirs.get(directory) == "git"):
+        source = dirs.get(directory) if isinstance(dirs, dict) else None
+        # TWO different questions about the same clone. `driven`: a git call named it, which is a
+        # stronger signal than an incidental `cd` and wins the eviction contest — a `git log` counts.
+        # `working`: the verb CHANGES something there, which is what occupancy() may warn about.
+        if (previous or {}).get("driven") or source in ("git", "read"):
             entry["driven"] = True
+        if (previous or {}).get("working") or source == "git":
+            entry["working"] = True
         repos.append(entry)
     if repos or presence.get("repos") is not None:
         # Eviction is not FIFO: a clone a git command actually drove, and one visited many times,
         # outrank the incidental `cd` that would otherwise push it out of the eight slots.
-        keep = sorted(repos, key=lambda r: (bool(r.get("driven")), int(r.get("hits") or 0),
-                                            parse_time(r.get("ts")) or 0), reverse=True)[:MAX_REPOS]
+        keep = sorted(repos, key=lambda r: (bool(r.get("working")), bool(r.get("driven")),
+                                            int(r.get("hits") or 0), parse_time(r.get("ts")) or 0),
+                      reverse=True)[:MAX_REPOS]
         presence["repos"] = [r for r in repos if r in keep]
     snap["presence"] = presence
     return snap
@@ -905,6 +921,49 @@ def repo_scope(snap, now=None, window=None):
     return ids, roots
 
 
+
+def occupancy(snap, now=None, window=None):
+    """The clones a session OCCUPIES, as opposed to the ones it merely reached.
+
+    Occupied: the cwd clone, a clone where it edited a file, and a clone a git command actually
+    drove (``driven``). Reached-only is a clone a shell call read or cd'ed into — and conflating the
+    two has a measured cost: a read-only ``cd`` plus a ``sed`` of one doc marked a session as using
+    a clone, which made a peer session stop a running test suite and apologise for damage to work
+    that did not exist there. Reach stays visible as information; only occupancy warns.
+    """
+    now = now or time.time()
+    window = FILE_TTL if window is None else window
+    ids, roots = set(), set()
+    presence = presence_of(snap)
+    repo = snap.get("repo") if isinstance(snap.get("repo"), dict) else None
+    if repo is None:
+        repo = presence.get("repo") if isinstance(presence.get("repo"), dict) else None
+    if repo is None and snap.get("cwd"):
+        repo = repo_info(snap["cwd"])
+    if isinstance(repo, dict):  # where the session lives
+        if repo.get("id"):
+            ids.add(repo["id"])
+        if repo.get("root"):
+            roots.add(repo["root"])
+    for entry in presence.get("repos") or []:  # only the clones a WRITING git command drove
+        if not isinstance(entry, dict) or not entry.get("working"):
+            continue
+        if now - (parse_time(entry.get("ts")) or 0) > window:
+            continue
+        if isinstance(entry.get("id"), str):
+            ids.add(entry["id"])
+        if isinstance(entry.get("root"), str):
+            roots.add(entry["root"])
+    for item in recent_files(snap, now, window):  # and the clones whose files it edited
+        if isinstance(item.get("repo"), str):
+            ids.add(item["repo"])
+        rel, path = item.get("rel"), item.get("path")
+        if isinstance(rel, str) and rel and isinstance(path, str) and path.endswith(rel):
+            root = path[: len(path) - len(rel)].rstrip("/")
+            if root:
+                roots.add(root)
+    return ids, roots
+
 def same_file(a, b):
     """Two touched-file entries name the same file: same path, or same repo id and repo-relative path."""
     if a.get("path") == b.get("path"):
@@ -1492,8 +1551,14 @@ def relations(me, other, now, cfg):
     my_ids, my_roots = repo_scope(me, now)
     their_ids, their_roots = repo_scope(other, now)
     shared_roots = sorted(my_roots & their_roots)
+    # Reach and occupancy are different claims about the same clone: `sharedClones` is "both sides
+    # touched it", `occupiedClones` is "both sides are WORKING in it". Only the second warns.
+    my_live, their_live = occupancy(me, now), occupancy(other, now)
+    occupied_roots = sorted(my_live[1] & their_live[1])
+    occupied_ids = sorted(my_live[0] & their_live[0])
     rel = {"sameRepo": bool(my_ids & their_ids), "sameClone": bool(shared_roots),
            "sharedRepos": sorted(my_ids & their_ids), "sharedClones": shared_roots,
+           "occupiedClones": occupied_roots, "occupiedRepos": occupied_ids,
            "sameBranch": False, "overlap": []}
     rel["sameBranch"] = bool(mine.get("id") and mine.get("id") == theirs.get("id") and me.get("branch")
                              and me.get("branch") == other.get("branch"))
@@ -1569,7 +1634,11 @@ def session_lines(s, home, now, with_files=True):
     state = "bloqueada" if s.get("blocked") else {"working": "trabalhando", "idle": "ociosa", "blocked": "bloqueada",
                                                   "error": "com erro"}.get(s.get("state"), clean(s.get("state") or "?", 12))
     root = (s.get("repo") or {}).get("root") or s.get("cwd") or "?"
-    where = ("MESMO clone " if root in (rel.get("sharedClones") or []) else "clone ") + short_path(root)
+    occupied = rel.get("occupiedClones")
+    occupied = occupied if isinstance(occupied, list) else (rel.get("sharedClones") or [])
+    where = ("MESMO clone " if root in occupied
+             else "leu/rodou comando em " if root in (rel.get("sharedClones") or [])
+             else "clone ") + short_path(root)
     head = "- " + clean(s.get("host"), 12) + " " + state + " · branch " + clean(s.get("branch") or "?", 60) + \
            (" (a mesma)" if rel.get("sameBranch") else "") + " · " + where + " · " + age_text(s.get("ageSeconds"))
     lines = [head[:LINE_CHARS]]
@@ -1584,10 +1653,18 @@ def session_lines(s, home, now, with_files=True):
             names = [clean(f["rel"], 80) if f.get("rel") else short_path(f["path"], 60) for f in reversed(files)]
             shown = ", ".join(names[:4]) + (" (+" + str(len(names) - 4) + ")" if len(names) > 4 else "")
             lines.append(("  arquivos editados: " + shown)[:LINE_CHARS])
-    shared = [r for r in (rel.get("sharedRepos") or []) if r != (s.get("repo") or {}).get("id")]
-    if shared:
+    mine_id = (s.get("repo") or {}).get("id")
+    shared = [r for r in (rel.get("sharedRepos") or []) if r != mine_id]
+    # "trabalha em" was claiming too much: a read-only visit landed here too, and a peer session
+    # stopped a running suite over it. The two claims are now separate lines.
+    busy = [r for r in shared if r in (rel.get("occupiedRepos") or [])]
+    read = [r for r in shared if r not in (rel.get("occupiedRepos") or [])]
+    if busy:
         lines.append(("  TAMBÉM trabalha em repositório(s) deste trabalho: " +
-                      ", ".join(clean(r, 60) for r in shared[:3]))[:LINE_CHARS])
+                      ", ".join(clean(r, 60) for r in busy[:3]))[:LINE_CHARS])
+    if read:
+        lines.append(("  leu/rodou comando em repositório(s) deste trabalho (sem editar): " +
+                      ", ".join(clean(r, 60) for r in read[:3]))[:LINE_CHARS])
     if rel.get("overlap"):
         lines.append(("  SOBREPOSIÇÃO com arquivos desta sessão: " + ", ".join(clean(x, 80) for x in rel["overlap"][:4]))[:LINE_CHARS])
     return lines
@@ -1660,7 +1737,7 @@ def digest(home, me_key, me=None, now=None, cfg=None, deliver=True):
         lines.append(claim_line(claim, live_by_key, now))
     my_root = (view["me"].get("repo") or {}).get("root")
     tail = []
-    if my_root and any(my_root in ((s.get("relation") or {}).get("sharedClones") or []) for s in others):
+    if my_root and any(my_root in ((s.get("relation") or {}).get("occupiedClones") or []) for s in others):
         tail.append("ATENÇÃO: outra sessão viva trabalha neste mesmo clone (cwd, edição ou comando); "
                     "não faça checkout/switch/rebase/stash aqui.")
     tail.append(FOOTER)
@@ -1710,7 +1787,7 @@ def check(home, me_key, me, paths=(), tree_change=(), now=None, cfg=None):
             warnings.append("- " + clean(", ".join(hits[:4]), 160) + ": editado " + age_text(s.get("ageSeconds")) + " por " +
                             clean(s.get("host"), 12) + " (branch " + clean(s.get("branch") or "?", 60) + ", " +
                             short_path((s.get("repo") or {}).get("root") or s.get("cwd") or "?") + ")")
-        theirs_root = next((r for r in sorted(repo_scope(s, now)[1]) if r in tree_roots), None)
+        theirs_root = next((r for r in sorted(occupancy(s, now)[1]) if r in tree_roots), None)
         if theirs_root:
             warnings.append("- o clone " + short_path(theirs_root) + " está em uso por " + clean(s.get("host"), 12) +
                             " na branch " + clean(s.get("branch") or "?", 60) + "; trocar de branch, rebase, stash ou reset aqui "

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andespindola/crow-skills",
-  "version": "0.18.2",
+  "version": "0.19.1",
   "description": "Versioned, complementary agent skills with a protected multi-agent installer",
   "license": "UNLICENSED",
   "repository": {

package/release.json

@@ -18,7 +18,7 @@
     "crow_skills/__init__.py": {
       "executable": false,
       "kind": "file",
-      "sha256": "985f4a517618b99f51bf9a9d98121075293b712b2a0a91b5666375d5853546ea"
+      "sha256": "0fac3e997aef5911a1a83e61ec8abc3b92abc0e02cdff187a430b3277e40b80f"
     },
     "crow_skills/__main__.py": {
       "executable": false,
@@ -38,7 +38,7 @@
     "crow_skills/broadcast.py": {
       "executable": false,
       "kind": "file",
-      "sha256": "354f013d999adec87ccfd69e8ae2fce749593b9c2043b41116d069e57e213ccc"
+      "sha256": "135fb80925dea8e6c0790ee830c6b7e440cc5c0f116a4c9dcc4cf36bab1c22e3"
     },
     "crow_skills/cli.py": {
       "executable": false,
@@ -128,7 +128,7 @@
     "package.json": {
       "executable": false,
       "kind": "file",
-      "sha256": "07b5468a007188905565bf5636d3d37919b93aae840b54a879a90625ba668d2a"
+      "sha256": "25d9d44e380c13b64264f33b18d0b722a1b465c693fd92d819581b78df7f6fb8"
     },
     "skills/crow-accessibility/SKILL.md": {
       "executable": false,
@@ -173,7 +173,7 @@
     "skills/crow-behaviour/references/broadcast.md": {
       "executable": false,
       "kind": "file",
-      "sha256": "5ec341809cf357d303df81a69822e7cff5fe979f2187ee623961ff197fe6cd2c"
+      "sha256": "6653d4495b49856e2e8299dcb048f8b7e5b785a741367e6d25350e1f9aeb1cb3"
     },
     "skills/crow-behaviour/references/context-economy.md": {
       "executable": false,
@@ -721,7 +721,7 @@
       "sha256": "e37132ef8b060548191fbf14a5a18a9dd3acd84ea9a35e802174455b9e374d3d"
     }
   },
-  "revision": "92f37cb4b5af7c738adbe218b3911a41f5cab202",
+  "revision": "2a8fb8a28c5b1073fd5faea2da0e2b4fe631fab7",
   "schema_version": 1,
-  "version": "0.18.2"
+  "version": "0.19.1"
 }

package/skills/crow-behaviour/references/broadcast.md

@@ -37,6 +37,15 @@ crow-skills broadcast release --all        # ao concluir ou cancelar (só as des
 - Libere ao terminar cada fase ou a execução. Reservas expiram pelo TTL (máximo 24 h) e somem quando a sessão dona deixa de estar viva.
 - Sem outras sessões vivas no repositório, não reserve: é ruído.
 
+## Alcance não é ocupação
+
+O bloco distingue duas alegações sobre o mesmo clone, e só uma é motivo para parar:
+
+- **`MESMO clone` / "TAMBÉM trabalha em"** — a outra sessão **ocupa** o clone: é o cwd dela, ela editou arquivo ali ou rodou git ali. Aqui vale a regra: não faça checkout, switch, rebase ou stash, e combine antes de editar.
+- **"leu/rodou comando em"** — ela só **alcançou** o clone: leu um arquivo, entrou nele num comando. É informação, não conflito. Não pare o seu trabalho por isso e não peça para ela parar o dela.
+
+Isso existe porque confundir os dois custou caro uma vez: um `cd` com um `sed` de leitura marcou uma sessão como estando no clone, e a outra interrompeu uma suíte em execução e pediu desculpas por um dano que não existia.
+
 ## Falar com outra sessão
 
 O bloco diz quem está vivo; o canal serve para dizer algo a quem está vivo. Vale entre CLIs diferentes — uma sessão do Codex alcança uma do Claude, porque o transporte é o hook, que todas têm.