@andespindola/crow-skills 0.13.1 → 0.15.0

package/README.md

@@ -2,7 +2,7 @@
 
 Skills com escopo explícito, conhecimento especializado preservado e fluxos comuns reutilizáveis.
 
-**Versão 0.12.2** ([mudanças](CHANGELOG.md)): o snapshot de cada sessão (`crow-skills events snapshot`) passa a trazer o pid do CLI de agente e o terminal dele (`pid`, `tty`), para o crow-term achar o painel de cada sessão. A 0.12.1 corrigiu a proteção de processos registrados e um teste instável; a 0.12.0 fez a crow-behaviour passar a encerrar a árvore inteira de todo processo que a execução inicia (com timeout, registro no ledger e verificação no fim) e `crow-skills resources --orphans` encontra e, com `--kill`, encerra só o que ficou órfão de ferramentas de agente. A 0.11.1 fez o Codex deixar de mostrar em dobro as skills que o Uniflow já projeta em `~/.codex/skills`. A 0.11.0 trouxe `crow-skills setup --yes`, que configura de uma vez todos os CLIs de agente da máquina, e `crow-skills upgrade --yes`, que atualiza tudo numa só passada; os hooks que o crow-skills grava já saem habilitados (no Codex, aprovados pelo próprio `codex app-server`, só os do crow-skills; `--no-trust` desliga) e `status`/`doctor` mostram se cada CLI vai rodá-los; a ajuda ficou curta e organizada por tarefa. A 0.10.1 passou a tratar swap e CPU como eixos de pressão no controle de recursos (swap quase cheio e carga alta reduzem agentes, jobs e workers; nenhuma recomendação cresce com a pressão), mostrou a CPU% dos CLIs de agente, trouxe `crow-skills resources --exec-prefix` para rodar jobs pesados em prioridade baixa e as regras da crow-behaviour sob pressão (reduzir já, um job pesado por vez, não repetir verificação, validação ampla no CI); os hooks do Codex vão para o `config.toml` quando o `hooks.json` é symlink. A 0.10.0 trouxe o crow-broadcast, que compartilha, de forma passiva, o que cada sessão e cada CLI (Claude Code, Codex, Gemini CLI, Antigravity, Devin, inclusive dentro do Uniflow) está fazendo nesta máquina: repositório, clone, branch, execução crow em andamento e arquivos em edição; o prompt recebe um resumo só quando outra sessão viva está no mesmo repositório, editar um arquivo que outra sessão tocou ou trocar de branch num clone em uso gera aviso (ou bloqueio, se configurado), e `crow-skills broadcast claim` reserva áreas; a crow-behaviour consulta isso antes de planejar e reserva as áreas que delega ([crow-broadcast](docs/broadcast.md)). A 0.9.0 trouxe o controle de memória da máquina: `crow-skills resources` mede memória, pressão e os CLIs de agente em execução e recomenda quantos agentes, jobs pesados e workers rodar em paralelo; a crow-behaviour consulta essa recomendação antes de cada fan-out (sob `warn` reduz, sob `critical` segue sequencial), limita workers de builds e testes, reutiliza um dev server por projeto e encerra o que abriu, e 15 especialistas que sobem processos pesados ganharam a regra correspondente; o hook de prompt e as status lines só avisam quando a máquina está sob pressão. A 0.8.0 trouxe `crow-skills mode on|off`, que liga e desliga a crow-behaviour em todas as sessões e CLIs (Claude Code, Codex, Gemini CLI, Antigravity, Devin) a partir do próximo prompt, com `/crow on|off` dentro da sessão e o indicador `▸▸ crow on` na status line; a crow-behaviour mostra o progresso como a lista de agentes do host (`● main`, `○ dono  atividade`); `crow-skills events` publica um barramento de eventos dos hooks para terminais; `crow-skills autoupdate on` atualiza o CLI e as skills gerenciadas todo dia e no login. A 0.7.1 trouxe as correções da revalidação no Codex às skills especialistas; a 0.7.0 tornou o Uniflow agente de instalação (`--agents uniflow`); a 0.6.1 passou a mostrar o progresso da crow-behaviour na própria conversa; a 0.6.0 trouxe as regras de entrega das 32 skills especialistas, a partir da [validação no Codex](docs/evaluations/2026-10-26-codex.md).
+**Versão 0.12.2** ([mudanças](CHANGELOG.md)): o snapshot de cada sessão (`crow-skills events snapshot`) passa a trazer o pid do CLI de agente e o terminal dele (`pid`, `tty`), para o crow-term achar o painel de cada sessão. A 0.12.1 corrigiu a proteção de processos registrados e um teste instável; a 0.12.0 fez a crow-behaviour passar a encerrar a árvore inteira de todo processo que a execução inicia (com timeout, registro no ledger e verificação no fim) e `crow-skills resources --orphans` encontra e, com `--kill`, encerra só o que ficou órfão de ferramentas de agente. A 0.11.1 fez o Codex deixar de mostrar em dobro as skills que o Uniflow já projeta em `~/.codex/skills`. A 0.11.0 trouxe `crow-skills setup --yes`, que configura de uma vez todos os CLIs de agente da máquina, e `crow-skills upgrade --yes`, que atualiza tudo numa só passada; os hooks que o crow-skills grava já saem habilitados (no Codex, aprovados pelo próprio `codex app-server`, só os do crow-skills; `--no-trust` desliga) e `status`/`doctor` mostram se cada CLI vai rodá-los; a ajuda ficou curta e organizada por tarefa. A 0.10.1 passou a tratar swap e CPU como eixos de pressão no controle de recursos (swap quase cheio e carga alta reduzem agentes, jobs e workers; nenhuma recomendação cresce com a pressão), mostrou a CPU% dos CLIs de agente, trouxe `crow-skills resources --exec-prefix` para rodar jobs pesados em prioridade baixa e as regras da crow-behaviour sob pressão (reduzir já, um job pesado por vez, não repetir verificação, validação ampla no CI); os hooks do Codex vão para o `config.toml` quando o `hooks.json` é symlink. A 0.10.0 trouxe o crow-broadcast, que compartilha, de forma passiva, o que cada sessão e cada CLI (Claude Code, Codex, Gemini CLI, Antigravity, Devin, inclusive dentro do Uniflow) está fazendo nesta máquina: repositório, clone, branch, execução crow em andamento e arquivos em edição; o prompt recebe em toda mensagem um bloco com as sessões vivas que afetam este trabalho (ou uma linha dizendo que não há nenhuma), editar um arquivo que outra sessão tocou ou trocar de branch num clone em uso gera aviso (ou bloqueio, se configurado), e `crow-skills broadcast claim` reserva áreas; a crow-behaviour consulta isso antes de planejar e reserva as áreas que delega ([crow-broadcast](docs/broadcast.md)). A 0.9.0 trouxe o controle de memória da máquina: `crow-skills resources` mede memória, pressão e os CLIs de agente em execução e recomenda quantos agentes, jobs pesados e workers rodar em paralelo; a crow-behaviour consulta essa recomendação antes de cada fan-out (sob `warn` reduz, sob `critical` segue sequencial), limita workers de builds e testes, reutiliza um dev server por projeto e encerra o que abriu, e 15 especialistas que sobem processos pesados ganharam a regra correspondente; o hook de prompt e as status lines só avisam quando a máquina está sob pressão. A 0.8.0 trouxe `crow-skills mode on|off`, que liga e desliga a crow-behaviour em todas as sessões e CLIs (Claude Code, Codex, Gemini CLI, Antigravity, Devin) a partir do próximo prompt, com `/crow on|off` dentro da sessão e o indicador `▸▸ crow on` na status line; a crow-behaviour mostra o progresso como a lista de agentes do host (`● main`, `○ dono  atividade`); `crow-skills events` publica um barramento de eventos dos hooks para terminais; `crow-skills autoupdate on` atualiza o CLI e as skills gerenciadas todo dia e no login. A 0.7.1 trouxe as correções da revalidação no Codex às skills especialistas; a 0.7.0 tornou o Uniflow agente de instalação (`--agents uniflow`); a 0.6.1 passou a mostrar o progresso da crow-behaviour na própria conversa; a 0.6.0 trouxe as regras de entrega das 32 skills especialistas, a partir da [validação no Codex](docs/evaluations/2026-10-26-codex.md).
 
 **Reconstrução em andamento.** A primeira versão com 32 contratos genéricos não atende à preservação de capacidades solicitada. Não use esse número nem o mapeamento por categoria como prova de substituição das originais. A revisão passa a abranger cada definição e seus recursos, modos e dependências, sem número fixo de skills ou limite artificial de linhas. Veja [critérios e progresso](docs/reconstruction.md).
 
@@ -26,7 +26,7 @@ npm install -g @andespindola/crow-skills && crow-skills setup --yes
 4. Entregue o artefato com alvo/revisão, evidência e pendências. Desconhecido não significa aprovado.
 5. Carregue outra skill só quando houver decisão distinta a tomar. Handoffs são opcionais, não dependências ocultas.
 
-Para adotar uma atuação mais coordenada em qualquer domínio, use `crow-behaviour`: todo pedido que não seja conversa, pergunta factual curta ou ajuste trivial e local recebe plano, delegação suportada, verificação e síntese, mantidos nos prompts seguintes da sessão; só essas exceções continuam diretas. A skill adapta o comportamento às ferramentas reais, inclusive execução sequencial, sem depender do Workflow do Claude. Fora dessas exceções ela mantém um ledger de progresso (`.crow/runs/`) e mostra na conversa o bloco de processos no formato da lista de agentes do host (`● main  …` e `○ dono  atividade` por unidade em andamento); `crow-skills progress --watch` e as status lines mostram o mesmo. `crow-skills mode on|off` (ou `/crow on|off`) a liga ou desliga em todos os CLIs. Com várias sessões ou CLIs no mesmo repositório, ela lê o crow-broadcast (`crow-skills broadcast`) para não duplicar trabalho nem trocar a branch de um clone em uso, e reserva as áreas que delega. Ela não muda o modelo/effort. [Escopo e evidência](analysis/crow-behaviour.md).
+Para adotar uma atuação mais coordenada em qualquer domínio, use `crow-behaviour`: todo pedido que não seja conversa, pergunta factual curta ou ajuste trivial e local recebe plano, delegação suportada, verificação e síntese, mantidos nos prompts seguintes da sessão; só essas exceções continuam diretas. A skill adapta o comportamento às ferramentas reais, inclusive execução sequencial, sem depender do Workflow do Claude. Fora dessas exceções ela mantém um ledger de progresso (`.crow/runs/`) e mostra na conversa o bloco de processos no formato da lista de agentes do host (`● main  …` e `○ dono  atividade` por unidade em andamento); `crow-skills progress --watch` e as status lines mostram o mesmo. `crow-skills mode on|off` (ou `/crow on|off`) a liga ou desliga em todos os CLIs. Com várias sessões ou CLIs nos mesmos repositórios, ela lê o bloco do crow-broadcast que chega em todo prompt (`crow-skills broadcast` detalha) para não duplicar trabalho nem trocar a branch de um clone em uso, e reserva as áreas que delega. Ela não muda o modelo/effort. [Escopo e evidência](analysis/crow-behaviour.md).
 
 Exemplos:
 - Plataforma nova: `crow-platform` coordena; `crow-discovery` e `crow-spec` definem o que falta; as especialistas implementam/verificam por fatia.

package/crow_skills/__init__.py

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

package/crow_skills/agents.py

@@ -4,18 +4,47 @@ import os
 import shutil
 from .source import CrowError
 
+# Every destination is the CLI's OWN skills directory. There is no shared folder: the
+# ~/.agents/skills store that codex used until 0.14.0 made crow-skills act on a directory
+# instead of on an agent, which showed up as a phantom "codex,shared" agent and let Codex
+# list the same skill twice (its own dir plus the shared one). LEGACY_SHARED stays named
+# only so an install made there can be found and migrated away.
+LEGACY_SHARED = ".agents/skills"
 AGENTS = {
-    "codex": (".agents/skills", ".agents/skills", "codex"),
+    "codex": (".codex/skills", ".codex/skills", "codex"),
     "claude": (".claude/skills", ".claude/skills", "claude"),
     "gemini": (".gemini/skills", ".gemini/skills", "gemini"),
     "devin": (".config/devin/skills", ".devin/skills", "devin"),
-    "shared": (".agents/skills", ".agents/skills", None),
     # Uniflow keeps one store and links it into each CLI's user skills dir; it has
     # no project scope. The store sits beside config.json (see uniflow_store).
     "uniflow": (".config/uniflow/skills", None, "uniflow"),
 }
 
 
+def codex_home(home):
+    """$CODEX_HOME for the real profile (as Codex resolves it); an isolated --home uses <home>/.codex.
+
+    A RELATIVE $CODEX_HOME is ignored: os.path.abspath would resolve it against this process's cwd,
+    which is not Codex's, so the destination would depend on where the command was run and could
+    land inside the user's repository. Only an absolute (or ~-anchored) value is honoured."""
+    home = Path(home)
+    raw = os.environ.get("CODEX_HOME") if real_home(home) else None
+    if raw:
+        expanded = Path(raw).expanduser()
+        if expanded.is_absolute():
+            return Path(os.path.abspath(expanded))
+    return Path(os.path.abspath(home / ".codex"))
+
+
+def codex_skills_dir(home):
+    return codex_home(home) / "skills"
+
+
+def legacy_shared_dir(home):
+    """Where codex installs landed until 0.14.0; read only, to migrate what is still there."""
+    return Path(os.path.abspath(Path(home) / LEGACY_SHARED))
+
+
 def real_home(home):
     """Environment overrides describe the real profile; an isolated --home ignores them."""
     return home == Path.home().resolve()
@@ -74,6 +103,10 @@ def destinations(names, home, project=None, custom=None):
         # Respect explicit XDG config, but isolate it when --home selects another profile.
         if name == "devin" and not project and real_home(home) and os.getenv("XDG_CONFIG_HOME"):
             path = Path(os.environ["XDG_CONFIG_HOME"]).expanduser() / "devin/skills"
+        # Codex resolves its own home through $CODEX_HOME; the destination must follow it, or an
+        # install would write beside a profile Codex never reads.
+        if name == "codex" and not project:
+            path = codex_skills_dir(home)
         if name == "uniflow":
             path = uniflow_store(home)
         key = str(path.absolute())

package/crow_skills/autoupdate.py

@@ -29,7 +29,7 @@ import subprocess
 import sys
 
 from . import __version__
-from .agents import destinations
+from .agents import destinations, legacy_shared_dir
 from .guide import protect, read_regular, sha, write_atomic
 from .source import CrowError, Source, same_source
 from .storage import atomic_json, checked, private_dir, read_json
@@ -334,8 +334,9 @@ def reinstall_behaviour(home, entry, dry_run, trust):
 
 
 def codex_duplicates(home, store, entry, names, dry_run):
-    """Codex sees Uniflow's links in ~/.codex/skills: those names are not updated natively, and intact managed
-    native copies of them are removed through uninstall (backup, transaction). Returns the names to update."""
+    """Codex sees Uniflow's links in its own dir: those names are not updated there, and intact managed copies
+    left in the legacy shared folder are removed through uninstall against THAT folder (backup, transaction).
+    Returns the names to update."""
     from . import projection
     from .cli import parser, run as cli_run
     seen = projection.projected("codex", home, store)
@@ -347,7 +348,8 @@ def codex_duplicates(home, store, entry, names, dry_run):
     entry["kept"] += [{"name": n, "status": "duplicate_modified"} for n in dupes["modified"]]
     entry["kept"] += [{"name": n, "status": "duplicate_shared"} for n in dupes["shared"]]
     if dupes["remove"]:
-        argv = ["uninstall", *dupes["remove"], "--agents", "codex", "--global", "--json", "--home", str(home),
+        # --dest na pasta legada: em ~/.codex/skills esses nomes são links do Uniflow e o uninstall recusaria.
+        argv = ["uninstall", *dupes["remove"], "--dest", str(legacy_shared_dir(home)), "--json", "--home", str(home),
                 "--dry-run" if dry_run else "--yes", "--no-integrations"]
         try:
             data = cli_run(parser().parse_args(argv))
@@ -411,6 +413,11 @@ def skills_update(home, trust=True, dry_run=False):
                     entry["error"] = {"code": exc.code, "message": str(exc)}
                 except (OSError, ValueError, KeyError, TypeError):
                     entry["error"] = {"code": "io_error", "message": "Falha de leitura/gravação; nada concluído para este agente."}
+                if agent == "codex" and not entry.get("error"):
+                    # Ramo mais provável de quem vinha da 0.14.0: no diretório do Codex só há links do
+                    # Uniflow, e TODAS as cópias do codex estão na pasta compartilhada. Sem migrar aqui,
+                    # uma máquina que só roda autoupdate nunca sai daquela pasta.
+                    machine.migrate_legacy(None, home, store, entry, dry_run, planned=projected)
                 results.append(entry)
             continue
         records = store.state(target["path"])["installed"]
@@ -455,6 +462,12 @@ def skills_update(home, trust=True, dry_run=False):
                 entry["error"] = {"code": exc.code, "message": str(exc)}
             except (OSError, ValueError, KeyError, TypeError):
                 entry["error"] = {"code": "io_error", "message": "Falha de leitura/gravação; nada concluído para este agente."}
+        if agent == "codex" and not entry.get("error"):
+            # Mesma migração do setup, e pelo mesmo motivo: sem isto, uma máquina que só roda
+            # autoupdate/upgrade mantém a pasta compartilhada antiga para sempre. Depois da
+            # atualização, nunca antes.
+            from . import machine
+            machine.migrate_legacy(None, home, store, entry, dry_run)
         results.append(entry)
     return results
 

package/crow_skills/broadcast.py

@@ -49,6 +49,7 @@ SESSION_SCHEMA = "crow-session/1"
 DEFAULTS = {"enabled": True, "block_on_conflict": False, "conflict_window_minutes": 30, "stale_minutes": 30,
             "pid_alive_hours": 12, "digest_max_sessions": 4}
 MAX_FILES = 40  # paths kept per session
+MAX_REPOS = 8  # clones kept per session (cwd apart): the ones its edits and shell calls reached
 FILE_TTL = 6 * 3600  # a touched path older than this is forgotten
 MAX_CLAIMS = 200
 MAX_CLAIM_TTL = 24 * 3600
@@ -343,6 +344,7 @@ 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")
 
 
@@ -359,10 +361,32 @@ def tree_command(host, tool, tool_input, cwd=None):
         return []
     here = cwd if isinstance(cwd, str) and cwd.startswith("/") else None
     targets = []
-    _scan(command[:64 * 1024], here, targets, 0)
+    _scan(strip_heredocs(command[:64 * 1024]), here, targets, 0)
     return targets
 
 
+HEREDOC = re.compile(r"<<-?\s*(['\"]?)([A-Za-z_][A-Za-z0-9_]*)\1")
+
+
+def strip_heredocs(command):
+    """Drop heredoc bodies before the command is scanned: their lines are data being written to a
+    file, not commands this session runs. Without this a `cd <clone>` inside a script being written
+    would publish that clone as presence and tell the sessions there not to change branch."""
+    out, rest = [], command
+    while True:
+        match = HEREDOC.search(rest)
+        if not match:
+            out.append(rest)
+            break
+        out.append(rest[: match.end()])
+        body = rest[match.end():]
+        end = re.search(r"^[ \t]*" + re.escape(match.group(2)) + r"[ \t]*$", body, re.MULTILINE)
+        if end is None:  # unterminated: everything after the marker is body
+            break
+        rest = body[end.end():]
+    return "".join(out)
+
+
 def _tokens(command):
     """Shell words and separators; a newline separates commands like ';'. Unbalanced quotes
     (an apostrophe in a message) fall back to a plain split instead of giving up."""
@@ -376,22 +400,35 @@ def _tokens(command):
         return [t for t in re.split(r"(\s+|[;&|()]+)", text) if t and not t.isspace()]
 
 
-def _scan(command, here, targets, depth):
+def _scan(command, here, targets, depth, visited=None):
     segment = []
     for token in _tokens(command) + [";"]:
         if token and set(token) <= set(";&|()"):
-            here = _segment(segment, here, targets, depth)
+            here = _segment(segment, here, targets, depth, visited)
             segment = []
         else:
             segment.append(token)
     return here
 
 
+def _note(visited, directory, source="cd"):
+    """Collect a directory a command works in, with how it got there (never the command itself).
+    `git` outranks `cd` when the session has more clones than it can publish."""
+    if visited is None or not directory or not directory.startswith("/"):
+        return
+    if directory in visited:
+        if source == "git":
+            visited[directory] = "git"
+        return
+    if len(visited) < MAX_PATTERNS:
+        visited[directory] = source
+
+
 WRAPPER_ARGS = {"sudo": ("-u", "-g", "-h", "-p", "-C", "-D", "-r", "-t"), "env": ("-u", "-C", "-S"), "nice": ("-n",),
                 "timeout": ("-s", "-k"), "time": (), "nohup": (), "command": (), "exec": ("-a",), "xargs": ()}
 
 
-def _segment(words, here, targets, depth=0):
+def _segment(words, here, targets, depth=0, visited=None):
     """One simple command: returns the directory after it (cd) and appends git work-tree targets."""
     words = list(words)
     while words:
@@ -412,12 +449,14 @@ def _segment(words, here, targets, depth=0):
     if re.match(r"^(?:\S*/)?(?:ba|z|da|k)?sh$", words[0]) and "-c" in words[1:] and depth < 2:
         index = words.index("-c")
         if index + 1 < len(words):
-            _scan(words[index + 1], here, targets, depth + 1)
+            _scan(words[index + 1], here, targets, depth + 1, visited)
         return here
     if words[0] == "cd":
         target = words[1] if len(words) > 1 else None
         if target and not target.startswith("-"):
-            return os.path.normpath(os.path.join(here or "/", os.path.expanduser(target))) if (here or target.startswith("/")) else None
+            moved = os.path.normpath(os.path.join(here or "/", os.path.expanduser(target))) if (here or target.startswith("/")) else None
+            _note(visited, moved)
+            return moved
         return here
     if not GIT_WORD.match(words[0]):
         return here
@@ -443,12 +482,56 @@ def _segment(words, here, targets, depth=0):
     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
     if sub in TREE_SUBCOMMANDS or (sub == "reset" and "--hard" in rest):
         if directory and directory not in targets:
             targets.append(directory)
     return here
 
 
+def shell_dirs(host, tool, tool_input, cwd=None, with_source=False):
+    """Directories other than its own cwd where a shell call works (`cd DIR`, `git -C DIR`,
+    `git --work-tree DIR`); [] for anything else. Only directories leave this function: the
+    command is read here and never stored. They become the session's published clones, so a
+    session driving a repository it did not start in stops being invisible to the others.
+    with_source: return {directory: "git"|"cd"} instead of a list, so the presence can keep the
+    clone a git command drove rather than the last `cd` the session happened to run."""
+    if tool not in SHELL_TOOLS or not isinstance(tool_input, dict):
+        return []
+    command = tool_input.get("command") or tool_input.get("cmd") or tool_input.get("CommandLine") or tool_input.get("commandLine")
+    if isinstance(command, list):
+        command = " ".join(str(x) for x in command if isinstance(x, str))
+    if not isinstance(command, str) or not DIR_WORD.search(command[:64 * 1024]):
+        return {} if with_source else []  # same short circuit tree_command has: no `cd`/`git` word
+    here = cwd if isinstance(cwd, str) and cwd.startswith("/") else None
+    visited = {}
+    _scan(strip_heredocs(command[:64 * 1024]), here, [], 0, visited)
+    found = [d for d in visited if d != here][:MAX_REPOS]
+    return {d: visited[d] for d in found} if with_source else found
+
+
+def shell_scan(host, tool, tool_input, cwd=None):
+    """tree_command and shell_dirs in ONE parse: (work-tree targets, {directory: "git"|"cd"}).
+
+    The hook needs both on every shell event and tokenising is the whole cost, so a big command
+    line is never walked twice. Equivalent to calling the two functions separately."""
+    if tool not in SHELL_TOOLS or not isinstance(tool_input, dict):
+        return [], {}
+    command = tool_input.get("command") or tool_input.get("cmd") or tool_input.get("CommandLine") or tool_input.get("commandLine")
+    if isinstance(command, list):
+        command = " ".join(str(x) for x in command if isinstance(x, str))
+    if not isinstance(command, str):
+        return [], {}
+    command = command[:64 * 1024]
+    if not DIR_WORD.search(command):
+        return [], {}
+    here = cwd if isinstance(cwd, str) and cwd.startswith("/") else None
+    targets, visited = [], {}
+    _scan(strip_heredocs(command), here, targets, 0, visited)
+    found = [d for d in visited if d != here][:MAX_REPOS]
+    return targets, {d: visited[d] for d in found}
+
+
 def pid_alive(pid):
     if not isinstance(pid, int) or isinstance(pid, bool) or pid <= 1:
         return None
@@ -496,11 +579,13 @@ def tty_of(pid, runner=None):
     return tty_lookup(pid, runner)[0]
 
 
-def fold(snap, event, touched=(), now=None, ppid=None, cli_pid=None, tty_runner=None):
+def fold(snap, event, touched=(), now=None, ppid=None, cli_pid=None, tty_runner=None, dirs=()):
     """Update the session snapshot's presence object (in place) for one event.
 
     cli_pid: the agent CLI resolved from a process table (Stop/SessionEnd); once known and alive it
-    is the presence pid, so a hook started through a transient ``sh -c`` does not replace it."""
+    is the presence pid, so a hook started through a transient ``sh -c`` does not replace it.
+    dirs: directories a shell call worked in (crow_broadcast.shell_dirs); their clones are published
+    beside the cwd clone, so a session driving another repository is visible to the sessions there."""
     now = now or time.time()
     presence = snap.get("presence") if isinstance(snap.get("presence"), dict) else {}
     if cli_pid:
@@ -554,6 +639,29 @@ def fold(snap, event, touched=(), now=None, ppid=None, cli_pid=None, tty_runner=
             entry["rel"] = relative(path, target["root"])
         files.append(entry)
     presence["files"] = files[-MAX_FILES:]
+    # Clones this session reaches outside its cwd: shell directories, and the clone of every file it
+    # edited. Same TTL as the paths: an old visit stops counting as presence.
+    repos = [r for r in presence.get("repos") or [] if isinstance(r, dict) and isinstance(r.get("root"), str)
+             and now - (parse_time(r.get("ts")) or 0) <= FILE_TTL]
+    # Only the shell directories of THIS event: the clones of edited files are already derived from
+    # the paths themselves (repo_scope), so no event pays a filesystem walk per remembered file.
+    for directory in [d for d in (dirs or []) if isinstance(d, str)]:
+        found = repo_info(directory)
+        if not found or (repo and found["root"] == repo["root"]):
+            continue
+        previous = next((r for r in repos if r["root"] == found["root"]), None)
+        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"):
+            entry["driven"] = 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]
+        presence["repos"] = [r for r in repos if r in keep]
     snap["presence"] = presence
     return snap
 
@@ -630,6 +738,45 @@ def recent_files(snap, now, window=None):
     return out
 
 
+def repo_scope(snap, now=None, window=None):
+    """Every repository a session works in, not only the clone it was started from: its cwd clone,
+    the clones its shell calls reached and the clones of the files it touched. Returns
+    (repository ids, clone roots). This is what makes a session that edits or drives another
+    repository visible to the sessions working there."""
+    now = now or time.time()
+    window = FILE_TTL if window is None else window
+    ids, roots = set(), set()
+    presence = presence_of(snap)
+    if not isinstance(presence.get("repos"), list):
+        presence = dict(presence, repos=[])
+    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):
+        if repo.get("id"):
+            ids.add(repo["id"])
+        if repo.get("root"):
+            roots.add(repo["root"])
+    for entry in presence.get("repos") or []:
+        if not isinstance(entry, dict) or 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):
+        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"):
@@ -1080,12 +1227,19 @@ def git_branch(root):
 # --- relevance ------------------------------------------------------------------------------
 
 def relations(me, other, now, cfg):
-    """Why another session matters to me: same clone, same repo, same branch, overlapping files."""
+    """Why another session matters to me: shared clone, shared repository, same branch, overlapping
+    files. Shared is computed over everything each side works in (repo_scope), not only the clone it
+    was started from: a session whose cwd is elsewhere but that edits or drives files in my
+    repository is relevant, which is the case the cwd-only comparison used to miss."""
     mine, theirs = me.get("repo") or {}, other.get("repo") or {}
-    rel = {"sameRepo": bool(mine.get("id") and mine.get("id") == theirs.get("id")),
-           "sameClone": bool(mine.get("root") and mine.get("root") == theirs.get("root")),
+    my_ids, my_roots = repo_scope(me, now)
+    their_ids, their_roots = repo_scope(other, now)
+    shared_roots = sorted(my_roots & their_roots)
+    rel = {"sameRepo": bool(my_ids & their_ids), "sameClone": bool(shared_roots),
+           "sharedRepos": sorted(my_ids & their_ids), "sharedClones": shared_roots,
            "sameBranch": False, "overlap": []}
-    rel["sameBranch"] = rel["sameRepo"] and bool(me.get("branch")) and me.get("branch") == other.get("branch")
+    rel["sameBranch"] = bool(mine.get("id") and mine.get("id") == theirs.get("id") and me.get("branch")
+                             and me.get("branch") == other.get("branch"))
     window = cfg["conflict_window_minutes"] * 60
     my_files = recent_files(me, now, FILE_TTL)
     for theirs_file in recent_files(other, now, window):
@@ -1123,10 +1277,12 @@ def overview(home, me_key=None, me=None, cwd=None, now=None, cfg=None):
         item["pid"] = presence.get("pid") if presence.get("pidStable") else None
         item["files"] = [{"path": f["path"], "rel": f.get("rel"), "repo": f.get("repo"), "ts": f.get("ts"), "tool": f.get("tool")}
                          for f in recent_files(s, now, FILE_TTL)][-10:]
+        item["repos"] = sorted(repo_scope(s, now)[0])
         item["relation"] = relations(me, s, now, cfg) if me else None
         sessions.append(item)
     return {"schema": BROADCAST_SCHEMA, "generatedAt": now_iso(now), "config": {k: cfg[k] for k in DEFAULTS},
-            "me": {"key": me_key, "cwd": (me or {}).get("cwd"), "repo": (me or {}).get("repo"), "branch": (me or {}).get("branch")}
+            "me": {"key": me_key, "cwd": (me or {}).get("cwd"), "repo": (me or {}).get("repo"), "branch": (me or {}).get("branch"),
+                   "repos": sorted(repo_scope(me, now)[0])}
             if me else None,
             "sessions": sessions, "claims": claims, "_live": live}
 
@@ -1155,7 +1311,8 @@ def session_lines(s, home, now, with_files=True):
     rel = s.get("relation") or {}
     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))
-    where = ("MESMO clone " if rel.get("sameClone") else "clone ") + short_path((s.get("repo") or {}).get("root") or s.get("cwd") or "?")
+    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)
     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]]
@@ -1170,6 +1327,10 @@ 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:
+        lines.append(("  TAMBÉM trabalha em repositório(s) deste trabalho: " +
+                      ", ".join(clean(r, 60) for r in shared[: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
@@ -1193,22 +1354,34 @@ FOOTER = ("Não edite arquivos em uso por outra sessão nem troque de branch num
           "usuário; reserve a área antes de delegar edições (crow-skills broadcast claim). Detalhe: crow-skills broadcast status --json.")
 
 
+def quiet_line(total, scope):
+    """The one-line form: the check ran and found nothing that touches this work. It is always
+    emitted so a session never has to remember to ask; the absence of the block is now a fact,
+    not a doubt."""
+    if not total:
+        return ("[crow-broadcast] Nenhuma outra sessão de agente viva nesta máquina agora. "
+                "Detalhe a qualquer momento: crow-skills broadcast status --json.")
+    where = "nenhuma nos repositórios deste trabalho" if scope else "e esta sessão não está num repositório conhecido"
+    return ("[crow-broadcast] " + str(total) + " outra(s) sessão(ões) de agente viva(s) nesta máquina, " + where +
+            " · antes de editar em outro clone: crow-skills broadcast status --json.")[:LINE_CHARS]
+
+
 def digest(home, me_key, me=None, now=None, cfg=None):
-    """The prompt-hook block, or None when no other live session is relevant (no noise)."""
+    """The prompt-hook block. Always present while the broadcast is enabled: the full block when
+    another live session touches this work, otherwise one line saying the check ran."""
     cfg = cfg or config(home)
     if not cfg["enabled"]:
         return None
     now = now or time.time()
     view = overview(home, me_key, me=me, now=now, cfg=cfg)
-    if view["me"] is None:
-        return None
-    others = relevant(view)
-    my_repo = (view["me"].get("repo") or {}).get("id")
+    scope = set() if view["me"] is None else repo_scope(me or {"cwd": view["me"].get("cwd"), "repo": view["me"].get("repo")}, now)[0]
+    others = relevant(view) if view["me"] is not None else []
+    my_repos = scope
     live_by_key = {s.get("key"): s for s in view["_live"]}
-    claims = [c for c in view["claims"] if (c.get("repo") or {}).get("id") == my_repo and my_repo
+    claims = [c for c in view["claims"] if (c.get("repo") or {}).get("id") in my_repos and my_repos
               and (c.get("owner") or {}).get("key") != me_key]
     if not others and not claims:
-        return None
+        return quiet_line(len(view["sessions"]), scope)
     lines = [HEADER]
     limit = int(cfg["digest_max_sessions"])
     for s in others[:limit]:
@@ -1217,12 +1390,18 @@ def digest(home, me_key, me=None, now=None, cfg=None):
         lines.append("- +" + str(len(others) - limit) + " outra(s) sessão(ões); veja crow-skills broadcast status")
     for claim in claims[:4]:
         lines.append(claim_line(claim, live_by_key, now))
-    if any((s.get("relation") or {}).get("sameClone") for s in others):
-        lines.append("ATENÇÃO: outra sessão viva usa este mesmo clone; não faça checkout/switch/rebase/stash aqui.")
-    lines.append(FOOTER)
-    text = "\n".join(lines)
+    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):
+        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)
+    # The warning and the footer are never what gets cut: truncation eats the session list.
+    text = "\n".join(lines + tail)
     if len(text) > DIGEST_CHARS:
-        text = text[: DIGEST_CHARS - len(FOOTER) - 3].rsplit("\n", 1)[0] + "\n…\n" + FOOTER
+        room = DIGEST_CHARS - len("\n".join(tail)) - 3
+        kept = "\n".join(lines)[:max(0, room)].rsplit("\n", 1)[0] if room > 0 else lines[0][:max(0, room)]
+        text = kept + "\n…\n" + "\n".join(tail)
     return text
 
 
@@ -1263,8 +1442,8 @@ 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 = (s.get("repo") or {}).get("root")
-        if theirs_root and theirs_root in tree_roots:
+        theirs_root = next((r for r in sorted(repo_scope(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 "
                             "muda os arquivos que ela está usando")