@andespindola/crow-skills 0.7.1 → 0.8.0

package/README.md

@@ -2,7 +2,7 @@
 
 Skills com escopo explícito, conhecimento especializado preservado e fluxos comuns reutilizáveis.
 
-**Versão 0.7.1** ([mudanças](CHANGELOG.md)): as skills especialistas recebem as correções da revalidação no Codex: injeção citada por inteiro após varrer o alvo, conflito com padrão adotado e reversão, contrato e documento de outro dono só como proposta sem pedido explícito, descartados completos e handoff que diz se a skill está instalada. 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.8.0** ([mudanças](CHANGELOG.md)): `crow-skills mode on|off` 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).
 
@@ -14,7 +14,7 @@ Skills com escopo explícito, conhecimento especializado preservado e fluxos com
 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`: tarefas substantivas recebem plano, delegação suportada, verificação e síntese; conversa e ajustes triviais continuam diretos. A skill adapta o comportamento às ferramentas reais, inclusive execução sequencial, sem depender do Workflow do Claude. Em tarefa substantiva ela mantém um ledger de progresso (`.crow/runs/`), mostra um resumo por fase no chat e, dentro do tmux, um painel ao vivo com `crow-skills progress --watch`. Ela não muda o modelo/effort nem força carregamento automático pelo host. [Escopo e evidência](analysis/crow-behaviour.md).
+Para adotar uma atuação mais coordenada em qualquer domínio, use `crow-behaviour`: tarefas substantivas recebem plano, delegação suportada, verificação e síntese; conversa e ajustes triviais continuam diretos. A skill adapta o comportamento às ferramentas reais, inclusive execução sequencial, sem depender do Workflow do Claude. Em tarefa substantiva 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. 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.
@@ -27,10 +27,11 @@ Exemplos:
 
 ## Instalação e portabilidade
 
-O pacote de cada skill é somente sua pasta em `skills/`. O [CLI crow-skills](docs/cli.md) instala cópias completas e versionadas em agentes/escopos explícitos, com preview, saída JSON, detecção de conflitos e recuperação. Requer Python 3.10+; Git para fontes em clone, Node 18+ para o launcher npm; mutações em macOS/Linux. A distribuição npm privada `@andespindola/crow-skills` inclui um snapshot completo das skills, sem clone ou hooks que as instalem automaticamente. No [Uniflow](docs/cli.md#uniflow), `--agents uniflow --global` grava as skills no store dele (`~/.config/uniflow/skills`), sem tocar no resto da configuração. Em `--global`, instalar a crow-behaviour também grava o guia aditivo do agente (claude, codex, gemini, devin) para usar as skills; `--no-guide` desliga. As integrações de interface (status line do Claude Code e do Codex, segmento tmux) seguem o mesmo fluxo, preservando a configuração existente; `--no-integrations` desliga.
+O pacote de cada skill é somente sua pasta em `skills/`. O [CLI crow-skills](docs/cli.md) instala cópias completas e versionadas em agentes/escopos explícitos, com preview, saída JSON, detecção de conflitos e recuperação. Requer Python 3.10+; Git para fontes em clone, Node 18+ para o launcher npm; mutações em macOS/Linux. A distribuição npm privada `@andespindola/crow-skills` inclui um snapshot completo das skills, sem clone ou hooks que as instalem automaticamente. No [Uniflow](docs/cli.md#uniflow), `--agents uniflow --global` grava as skills no store dele (`~/.config/uniflow/skills`), sem tocar no resto da configuração. Em `--global`, instalar a crow-behaviour também grava o guia aditivo do agente (claude, codex, gemini, devin) para usar as skills; `--no-guide` desliga. As integrações de interface (status lines do Claude Code, do Codex e do Antigravity, hooks do modo crow em cada CLI, comando `/crow`, segmento tmux) seguem o mesmo fluxo, preservando a configuração existente; `--no-integrations` desliga. O [barramento de eventos](docs/events.md) e a atualização automática (`crow-skills autoupdate on`) estão no [CLI](docs/cli.md).
 
 ```sh
-npm install -g @andespindola/crow-skills@0.7.1
+npm install -g @andespindola/crow-skills@0.8.0
+crow-skills mode
 crow-skills progress
 ./bin/crow-skills list
 ./bin/crow-skills install crow-behaviour --agents claude,codex --global --dry-run
@@ -40,7 +41,7 @@ crow-skills progress
 
 Também é possível copiar/referenciar manualmente as pastas escolhidas no diretório suportado pelo host. Para symlink manual, mantenha o checkout no mesmo caminho. O CLI v0.1 só instala cópias; não sobrescreve conflitos ou edições sem opção explícita e backup.
 
-Os nomes têm prefixo `crow-` para coexistir com o catálogo anterior. Não há instalação global automática nem auto-update; em `--global`, a única reconfiguração de agentes é o guia aditivo e as integrações de interface, ambos desligáveis (`--no-guide`, `--no-integrations`). O CLI mostra complementaridade por role/owner/handoffs e overlays, mas só instala as selecionadas; `--with-handoffs` é opt-in para handoffs diretos. Operações especializadas podem depender de ferramentas explicitamente documentadas: `crow-interface`, por exemplo, inclui adaptador de motor versionado e instalação explícita dessa dependência. A descoberta depende do runtime; presença do arquivo não prova carregamento.
+Os nomes têm prefixo `crow-` para coexistir com o catálogo anterior. Não há instalação global automática; auto-update só depois de `crow-skills autoupdate on` (agendador do usuário, desligável com `autoupdate off`), e ele nunca sobrescreve skills editadas. Em `--global`, a única reconfiguração de agentes é o guia aditivo e as integrações de interface (incluindo os hooks do modo crow), ambos desligáveis (`--no-guide`, `--no-integrations`). O CLI mostra complementaridade por role/owner/handoffs e overlays, mas só instala as selecionadas; `--with-handoffs` é opt-in para handoffs diretos. Operações especializadas podem depender de ferramentas explicitamente documentadas: `crow-interface`, por exemplo, inclui adaptador de motor versionado e instalação explícita dessa dependência. A descoberta depende do runtime; presença do arquivo não prova carregamento.
 
 Cada pacote mantém suas referências locais e declara dependências operacionais. Os nomes de próximos responsáveis são sugestões, não downloads implícitos. Sem ferramenta necessária, entregue somente o que puder comprovar e descreva a capacidade não executada, em vez de alegar equivalência.
 

package/crow_skills/__init__.py

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

package/crow_skills/autoupdate.py

@@ -0,0 +1,398 @@
+"""Scheduled self-upgrade of crow-skills and update of the managed skills.
+
+``on`` installs a user scheduler (macOS launchd LaunchAgent, Linux systemd
+--user timer) that runs ``crow-skills autoupdate run`` daily and at login.
+A run upgrades crow-skills the way it was installed (Homebrew tap, npm
+global; a Git checkout only when opted in with --git-pull and the checkout is
+clean on main/master), then updates every managed skill for every agent that
+has managed installs, with the same rules as ``update --global``: guides and
+integrations are regenerated, locally modified skills are never overwritten
+(they are reported), and a refusal for one agent never stops the others.
+
+Results go to ~/.local/state/crow-skills/autoupdate/state.json (last run and
+a short history), shown by ``autoupdate status``, ``doctor`` and
+``events snapshot``. Command output of brew/npm/git is never stored or
+printed: only exit codes and versions.
+"""
+from datetime import datetime, timezone
+import json
+import os
+from pathlib import Path
+import plistlib
+import re
+import shutil
+import subprocess
+import sys
+
+from . import __version__
+from .agents import destinations
+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
+
+LABEL = "com.andersonflima.crow-skills.autoupdate"
+UNIT = "crow-skills-autoupdate"
+FORMULA = "andersonflima/tap/crow-skills"
+PACKAGE = "@andespindola/crow-skills"
+HEADER = "# Gerenciado por crow-skills autoupdate. Não edite; use crow-skills autoupdate off."
+AGENT_ORDER = ("claude", "codex", "gemini", "devin", "uniflow")
+HISTORY = 20
+DAILY = {"Hour": 10, "Minute": 17}
+UNSAFE = re.compile(r"[\"'\\$`\n%]")
+
+
+def now():
+    return datetime.now(timezone.utc).isoformat(timespec="seconds")
+
+
+def root(store):
+    return store.root / "autoupdate"
+
+
+def state_path(store):
+    return root(store) / "state.json"
+
+
+def load_state(store):
+    path = checked(state_path(store))
+    if not path.exists():
+        return {"schema_version": 1, "enabled": False}
+    data = read_json(path)
+    if not isinstance(data, dict) or data.get("schema_version") != 1:
+        raise CrowError("invalid_state", "Estado do autoupdate inválido; nada alterado.")
+    return data
+
+
+def save_state(store, data):
+    private_dir(root(store))
+    atomic_json(state_path(store), data)
+
+
+# --- how crow-skills is installed --------------------------------------------------------
+
+def detect(source_root=None):
+    """kind brew|npm|git|unknown, the stable launcher and the upgrade command."""
+    base = Path(source_root or Path(__file__).resolve().parents[1]).resolve()
+    text = str(base)
+    brew = re.fullmatch(r"(.*)/Cellar/crow-skills/([^/]+)/libexec", text)
+    if brew:
+        prefix = Path(brew.group(1))
+        return {"kind": "brew", "root": text, "version": brew.group(2), "launcher": str(prefix / "bin" / "crow-skills"),
+                "upgrade": [str(prefix / "bin" / "brew"), "upgrade", FORMULA]}
+    npm = re.fullmatch(r"(.*)/lib/node_modules/@andespindola/crow-skills", text)
+    if npm:
+        prefix = Path(npm.group(1))
+        tool = prefix / "bin" / "npm"
+        return {"kind": "npm", "root": text, "version": __version__, "launcher": str(prefix / "bin" / "crow-skills"),
+                "upgrade": [str(tool) if tool.exists() else (shutil.which("npm") or "npm"), "install", "-g", PACKAGE + "@latest"]}
+    if (base / ".git").exists():
+        return {"kind": "git", "root": text, "version": __version__, "launcher": str(base / "bin" / "crow-skills"),
+                "upgrade": None}
+    return {"kind": "unknown", "root": text, "version": __version__, "launcher": shutil.which("crow-skills"), "upgrade": None}
+
+
+def platform_kind():
+    if sys.platform == "darwin":
+        return "launchd"
+    if sys.platform.startswith("linux"):
+        return "systemd"
+    return None
+
+
+def real_home(home):
+    return Path(home).resolve() == Path.home().resolve()
+
+
+# --- scheduler files ---------------------------------------------------------------------------
+
+def search_path(launcher):
+    dirs = [os.path.dirname(launcher)]
+    for tool in ("node", "python3", "git", "brew", "npm"):
+        found = shutil.which(tool)
+        if found:
+            dirs.append(os.path.dirname(found))
+    dirs += ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"]
+    return ":".join(dict.fromkeys(d for d in dirs if d))
+
+
+def scheduler_files(kind, store, home, launcher):
+    """{path: bytes} of the scheduler definition."""
+    log = str(root(store) / "scheduler.log")
+    args = [launcher, "autoupdate", "run", "--yes", "--json"]
+    if kind == "launchd":
+        plist = {"Label": LABEL, "ProgramArguments": args, "RunAtLoad": True, "StartCalendarInterval": DAILY,
+                 "EnvironmentVariables": {"PATH": search_path(launcher)}, "StandardOutPath": log, "StandardErrorPath": log,
+                 "ProcessType": "Background", "LowPriorityIO": True, "Nice": 10}
+        return {Path(home) / "Library" / "LaunchAgents" / (LABEL + ".plist"): plistlib.dumps(plist, sort_keys=True)}
+    if kind == "systemd":
+        if any(UNSAFE.search(a) for a in args + [log, search_path(launcher)]) or " " in search_path(launcher):
+            raise CrowError("unsafe_path", "Caminho do launcher contém aspas, $, % ou barra invertida; agende manualmente.")
+        command = " ".join('"' + a + '"' if " " in a else a for a in args)
+        base = Path(home) / ".config" / "systemd" / "user"
+        service = (HEADER + "\n[Unit]\nDescription=crow-skills autoupdate\n\n[Service]\nType=oneshot\n"
+                   "Environment=PATH=" + search_path(launcher) + "\nExecStart=" + command + "\nNice=10\n")
+        timer = (HEADER + "\n[Unit]\nDescription=crow-skills autoupdate (diário e no login)\n\n[Timer]\nOnCalendar=daily\n"
+                 "OnStartupSec=5min\nPersistent=true\nRandomizedDelaySec=30min\nUnit=" + UNIT + ".service\n\n"
+                 "[Install]\nWantedBy=timers.target\n")
+        return {base / (UNIT + ".service"): service.encode("utf-8"), base / (UNIT + ".timer"): timer.encode("utf-8")}
+    raise CrowError("unsupported_platform", "Sem agendador suportado nesta plataforma (launchd no macOS, systemd --user no Linux). "
+                    "Agende manualmente: crow-skills autoupdate run --yes --json, uma vez por dia (ex.: cron).")
+
+
+def run_quiet(command, timeout=60, cwd=None, env=None):
+    """Exit code only; output is discarded so nothing sensitive reaches state or logs."""
+    try:
+        done = subprocess.run(command, cwd=cwd, env=env, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL,
+                              stderr=subprocess.DEVNULL, timeout=timeout)
+        return done.returncode
+    except (OSError, subprocess.SubprocessError):
+        return None
+
+
+def activate(kind, files, home, enable):
+    """Load/unload the scheduler; only for the real profile (an isolated --home is never activated)."""
+    if not real_home(home):
+        return False, "Perfil isolado (--home): arquivos gravados, agendador não carregado."
+    if kind == "launchd":
+        plist = next(iter(files))
+        domain = "gui/" + str(os.getuid())
+        run_quiet(["launchctl", "bootout", domain + "/" + LABEL])
+        if not enable:
+            return True, None
+        code = run_quiet(["launchctl", "bootstrap", domain, str(plist)])
+        return code == 0, None if code == 0 else "launchctl bootstrap falhou (código " + str(code) + "); carregue com: launchctl bootstrap " + domain + " " + str(plist)
+    if not shutil.which("systemctl"):
+        return False, "systemctl indisponível; habilite manualmente: systemctl --user enable --now " + UNIT + ".timer"
+    if enable:
+        run_quiet(["systemctl", "--user", "daemon-reload"])
+        code = run_quiet(["systemctl", "--user", "enable", "--now", UNIT + ".timer"])
+        return code == 0, None if code == 0 else "systemctl --user enable falhou (código " + str(code) + ")."
+    run_quiet(["systemctl", "--user", "disable", "--now", UNIT + ".timer"])
+    run_quiet(["systemctl", "--user", "daemon-reload"])
+    return True, None
+
+
+def turn_on(store, home, dry_run=False, git_pull=False, launcher=None, kind=None):
+    state = load_state(store)
+    kind = kind or platform_kind()
+    install = detect()
+    launcher = launcher or install["launcher"]
+    if not launcher:
+        raise CrowError("launcher_not_found", "Não encontrei um launcher estável do crow-skills (brew, npm ou checkout).")
+    files = scheduler_files(kind, store, home, launcher)
+    previous = {f["path"]: f["sha256"] for f in (state.get("scheduler") or {}).get("files", [])}
+    changes = []
+    for path, data in files.items():
+        path = protect(path, home)
+        current = read_regular(path)
+        if current is not None and previous.get(str(path)) != sha(current):
+            raise CrowError("unmanaged_conflict", str(path) + " existe e não foi gravado pelo crow-skills; nada alterado.")
+        changes.append({"path": str(path), "action": "unchanged" if current == data else ("update" if current else "install")})
+    plan = {"scheduler": kind, "launcher": launcher, "install": install, "changes": changes, "git_pull": git_pull}
+    if dry_run:
+        return dict(plan, applied=False)
+    for path, data in files.items():
+        if not path.parent.exists():
+            path.parent.mkdir(parents=True, mode=0o755)
+        if read_regular(protect(path, home)) != data:
+            write_atomic(path, data, 0o644)
+    activated, note = activate(kind, files, home, True)
+    state.update(enabled=True, git_pull=bool(git_pull), scheduler={
+        "kind": kind, "label": LABEL if kind == "launchd" else UNIT, "launcher": launcher, "activated": activated,
+        "note": note, "installedAt": now(), "files": [{"path": str(p), "sha256": sha(d)} for p, d in files.items()]})
+    save_state(store, state)
+    return dict(plan, applied=True, activated=activated, note=note)
+
+
+def turn_off(store, home, dry_run=False):
+    state = load_state(store)
+    scheduler = state.get("scheduler") or {}
+    changes, kept = [], []
+    for item in scheduler.get("files", []):
+        path = protect(Path(item["path"]), home)
+        current = read_regular(path)
+        if current is None:
+            continue
+        if sha(current) != item["sha256"]:
+            kept.append({"path": str(path), "reason": "Arquivo alterado depois da instalação; mantido. Ele ainda pode ser "
+                         "carregado no próximo login: revise e remova-o você mesmo."})
+            continue
+        changes.append({"path": str(path), "action": "remove"})
+    if dry_run:
+        return {"changes": changes, "kept": kept, "applied": False}
+    if scheduler.get("kind"):
+        activate(scheduler["kind"], {Path(f["path"]): b"" for f in scheduler.get("files", [])}, home, False)
+    for change in changes:
+        Path(change["path"]).unlink()
+    state.update(enabled=False)
+    state.pop("scheduler", None)
+    save_state(store, state)
+    return {"changes": changes, "kept": kept, "applied": True}
+
+
+def status(store, home):
+    state = load_state(store)
+    scheduler = state.get("scheduler") or {}
+    files = []
+    for item in scheduler.get("files", []):
+        try:
+            current = read_regular(protect(Path(item["path"]), home))
+        except CrowError:
+            current = None
+        files.append({"path": item["path"], "status": "installed" if current is not None and sha(current) == item["sha256"]
+                      else ("missing" if current is None else "modified")})
+    last = state.get("lastRun")
+    return {"enabled": bool(state.get("enabled")), "scheduler": {k: v for k, v in scheduler.items() if k != "files"} or None,
+            "files": files, "install": detect(), "git_pull": bool(state.get("git_pull")),
+            "lastRun": last, "healthy": (not state.get("enabled") or all(f["status"] == "installed" for f in files))
+            and (last is None or bool(last.get("ok")))}
+
+
+# --- run ----------------------------------------------------------------------------------------
+
+def git_upgrade(base):
+    git = ["git", "--no-replace-objects", "-c", "core.hooksPath=/dev/null", "-C", base]
+    try:
+        dirty = subprocess.run(git + ["status", "--porcelain"], capture_output=True, text=True, timeout=30).stdout.strip()
+        branch = subprocess.run(git + ["rev-parse", "--abbrev-ref", "HEAD"], capture_output=True, text=True, timeout=30).stdout.strip()
+    except (OSError, subprocess.SubprocessError):
+        return {"result": "failed", "reason": "git indisponível"}
+    if dirty:
+        return {"result": "skipped", "reason": "checkout com alterações locais; não atualizado"}
+    if branch not in ("main", "master"):
+        return {"result": "skipped", "reason": "checkout fora de main/master (" + branch[:60] + "); não atualizado"}
+    code = run_quiet(git + ["pull", "--ff-only", "--no-rebase", "-q"], timeout=300)
+    return {"result": "ok" if code == 0 else "failed", "exitCode": code}
+
+
+def launcher_version(launcher):
+    try:
+        done = subprocess.run([launcher, "--version", "--json"], capture_output=True, text=True, timeout=60,
+                              stdin=subprocess.DEVNULL)
+        return json.loads(done.stdout)["data"]["version"]
+    except (OSError, subprocess.SubprocessError, ValueError, KeyError, TypeError):
+        return None
+
+
+def self_upgrade(install, git_pull):
+    if install["kind"] in ("brew", "npm"):
+        code = run_quiet(install["upgrade"], timeout=900)
+        after = launcher_version(install["launcher"]) if code == 0 else None
+        return {"kind": install["kind"], "result": "ok" if code == 0 else "failed", "exitCode": code,
+                "before": __version__, "after": after}
+    if install["kind"] == "git":
+        if not git_pull:
+            return {"kind": "git", "result": "skipped", "reason": "checkout git: atualize com git pull, ou ligue com autoupdate on --git-pull"}
+        result = git_upgrade(install["root"])
+        result.update(kind="git", before=__version__, after=launcher_version(install["launcher"]) if result["result"] == "ok" else None)
+        return result
+    return {"kind": "unknown", "result": "skipped", "reason": "instalação não reconhecida (brew, npm ou checkout git)"}
+
+
+def skills_update(home):
+    """update --global for every agent with managed installs; modified skills are kept and reported."""
+    from . import cli
+    from .cli import parser, run as cli_run
+    from .storage import Store
+    store = Store(home)
+    try:
+        current = Source(cli.DEFAULT_SOURCE)
+    except CrowError:
+        current = None
+    results, seen = [], set()
+    for agent in AGENT_ORDER:
+        try:
+            target = destinations(agent, home)[0]
+        except CrowError:
+            continue
+        if target["path"] in seen:
+            continue
+        seen.add(target["path"])
+        try:
+            rows = store.status([target])
+        except (CrowError, OSError) as exc:
+            results.append({"agent": agent, "error": {"code": getattr(exc, "code", "io_error"), "message": str(exc)}})
+            continue
+        rows = [r for r in rows if r["name"] and r["revision"]]
+        if not rows:
+            continue
+        records = store.state(target["path"])["installed"]
+        names, kept = [], []
+        for r in rows:
+            if r["status"] not in ("installed", "disabled"):
+                kept.append({"name": r["name"], "status": r["status"]})
+            elif current is not None and not same_source(records.get(r["name"], {}), current):
+                kept.append({"name": r["name"], "status": "other_origin"})  # update --source or install switches it
+            else:
+                names.append(r["name"])
+        entry = {"agent": agent, "target": target["path"], "updated": [], "unchanged": 0, "kept": kept, "error": None}
+        if names:
+            try:
+                args = parser().parse_args(["update", *names, "--agents", agent, "--global", "--yes", "--json", "--home", str(home)])
+                data = cli_run(args)
+                entry["updated"] = sorted({c["name"] for c in data["changes"] if c["action"] != "unchanged"})
+                entry["unchanged"] = sum(c["action"] == "unchanged" for c in data["changes"])
+                entry["transaction"] = data.get("transaction")
+                entry["guides"] = (data.get("guides") or {}).get("transaction")
+            except CrowError as exc:
+                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."}
+        results.append(entry)
+    return results
+
+
+def run(store, home, self_step=True, skills_step=True):
+    try:
+        import fcntl
+    except ImportError as exc:  # pragma: no cover
+        raise CrowError("unsupported_platform", "Autoupdate requer locks POSIX.") from exc
+    directory = private_dir(root(store))
+    lock = os.open(checked(directory / "run.lock"), os.O_RDWR | os.O_CREAT | getattr(os, "O_NOFOLLOW", 0), 0o600)
+    try:
+        try:
+            # The new version started by a self-upgrade runs under its parent's lock.
+            if os.environ.get("CROW_SKILLS_AUTOUPDATE_CHILD") != "1":
+                fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except OSError as exc:
+            raise CrowError("busy", "Outro autoupdate está em execução.") from exc
+        log = directory / "scheduler.log"
+        if log.exists() and log.stat().st_size > 256 * 1024:
+            log.write_text("")
+        state = load_state(store)
+        install = detect()
+        result = {"startedAt": now(), "version": __version__, "install": {"kind": install["kind"]}}
+        handed_off = False
+        if self_step:
+            result["self"] = self_upgrade(install, state.get("git_pull"))
+            after = result["self"].get("after")
+            if skills_step and after and after != __version__ and install["launcher"]:
+                # The new version updates the skills (its own snapshot is the new source).
+                try:
+                    done = subprocess.run([install["launcher"], "autoupdate", "run", "--skills-only", "--yes", "--json"],
+                                          capture_output=True, text=True, timeout=1200, stdin=subprocess.DEVNULL,
+                                          env=dict(os.environ, CROW_SKILLS_AUTOUPDATE_CHILD="1"))
+                    child = json.loads(done.stdout)
+                    result["skills"] = child["data"]["lastRun"]["skills"] if child.get("ok") else []
+                    result["handoff"] = {"version": after, "ok": bool(child.get("ok"))}
+                    handed_off = True
+                except (OSError, subprocess.SubprocessError, ValueError, KeyError, TypeError):
+                    result["handoff"] = {"version": after, "ok": False}
+                    handed_off = True
+        if skills_step and not handed_off:
+            result["skills"] = skills_update(home)
+        result["endedAt"] = now()
+        result["ok"] = (result.get("self", {}).get("result") != "failed"
+                        and all(not s.get("error") for s in result.get("skills", []))
+                        and result.get("handoff", {}).get("ok", True))
+        state = load_state(store)
+        state["lastRun"] = result
+        history = state.get("history") or []
+        history.append({"startedAt": result["startedAt"], "ok": result["ok"],
+                        "updated": sum(len(s.get("updated") or []) for s in result.get("skills", [])),
+                        "self": (result.get("self") or {}).get("result")})
+        state["history"] = history[-HISTORY:]
+        save_state(store, state)
+        return {"lastRun": result, "enabled": bool(state.get("enabled"))}
+    finally:
+        os.close(lock)

package/crow_skills/cli.py

@@ -6,7 +6,10 @@ from pathlib import Path
 import sys
 
 from . import __version__
+from . import autoupdate
+from . import events
 from . import guide
+from . import hook
 from . import integrations
 from . import progress
 from .agents import AGENTS, destinations, inventory
@@ -14,7 +17,7 @@ from .source import CrowError, Source, valid_name
 from .storage import Store, checked
 
 DEFAULT_SOURCE = Path(__file__).resolve().parents[1]
-MUTATIONS = {"install", "update", "uninstall", "rollback", "recover", "guide", "integrations"}
+MUTATIONS = {"install", "update", "uninstall", "rollback", "recover", "guide", "integrations", "mode", "autoupdate"}
 
 
 class Parser(argparse.ArgumentParser):
@@ -68,6 +71,17 @@ def parser():
     child.add_argument("--watch", action="store_true", help="Redesenhar até a execução terminar ou Ctrl-C")
     child.add_argument("--run", help="ID da execução; padrão: a ativa mais recente do diretório")
     child.add_argument("--cwd", help="Diretório da execução; padrão: o atual")
+    child = sub.add_parser("mode", parents=[common], help="Liga/desliga o modo crow (crow-behaviour) em todas as sessões e CLIs")
+    child.add_argument("action", nargs="?", default="status", choices=("on", "off", "status", "toggle"))
+    child = sub.add_parser("events", parents=[common], help="Barramento de eventos dos hooks (crow-event/1) para terminais")
+    child.add_argument("action", nargs="?", default="snapshot", choices=("snapshot", "tail"))
+    child.add_argument("--limit", type=int, default=50, help="tail: quantos eventos (padrão 50; 0 = todos os retidos)")
+    child.add_argument("--follow", action="store_true", help="tail: transmitir eventos novos em JSONL até Ctrl-C")
+    child = sub.add_parser("autoupdate", parents=[common], help="Atualização diária e no login do crow-skills e das skills gerenciadas")
+    child.add_argument("action", choices=("on", "off", "status", "run"))
+    child.add_argument("--git-pull", action="store_true", help="on: também atualizar um checkout git limpo em main/master (git pull --ff-only)")
+    child.add_argument("--skills-only", action="store_true", help="run: só atualizar as skills, sem atualizar o crow-skills")
+    child.add_argument("--no-self", action="store_true", help="run: igual a --skills-only")
     for name in ("rollback", "recover"):
         child = sub.add_parser(name, parents=[common])
         child.add_argument("--transaction", required=name == "rollback")
@@ -313,6 +327,61 @@ def progress_command(args, home):
     return data
 
 
+def mode_command(args, home):
+    current = hook.read_mode(home)
+    if args.action in ("on", "off", "toggle") and not getattr(args, "dry_run", False):
+        wanted = args.action if args.action != "toggle" else ("off" if current["mode"] == "on" else "on")
+        current = hook.write_mode(home, wanted, "cli")
+    try:
+        installed = [r["integration"] for r in integrations.status(Store(home), home)
+                     if r["status"] == "installed" and r["integration"].endswith(("-hooks", "-statusline", "-command", "tmux-status"))]
+    except CrowError:
+        installed = []
+    return {**current, "indicator": hook.indicator(current["mode"]), "integrations": installed,
+            "applies": "A partir do próximo prompt em toda sessão com o hook do crow-skills; sessões sem hook leem o modo ao abrir "
+                       "(guia) ou pelo usuário (crow-skills mode status).",
+            "dry_run": getattr(args, "dry_run", False)}
+
+
+def events_command(args, home, store):
+    if args.action == "tail":
+        if args.follow:
+            if getattr(args, "json", False):
+                raise CrowError("usage", "--follow transmite JSONL puro; não combine com --json.")
+            events.follow(home)
+            return None
+        return {"events": hook.tail(home, max(0, args.limit)), "schema": hook.EVENT_SCHEMA,
+                "path": str(hook.events_dir(home) / "events.jsonl")}
+    data = events.snapshot(home, store)
+    data["text"] = events.render(data, progress.unicode_ok())
+    return data
+
+
+def autoupdate_command(args, home, store, interactive):
+    if args.action == "status":
+        return autoupdate.status(store, home)
+    if args.action == "run":
+        authorize(args, interactive, {"autoupdate": "run", "self_upgrade": not (args.skills_only or args.no_self)})
+        if getattr(args, "dry_run", False):
+            return {"install": autoupdate.detect(), "applied": False,
+                    "would": ["atualizar o crow-skills" if not (args.skills_only or args.no_self) else None,
+                              "update --global das skills gerenciadas, por agente"]}
+        return autoupdate.run(store, home, self_step=not (args.skills_only or args.no_self))
+    if args.action == "on":
+        preview = autoupdate.turn_on(store, home, dry_run=True, git_pull=args.git_pull)
+        if any(c["action"] != "unchanged" for c in preview["changes"]):
+            authorize(args, interactive, preview)
+        if getattr(args, "dry_run", False):
+            return preview
+        return autoupdate.turn_on(store, home, git_pull=args.git_pull)
+    preview = autoupdate.turn_off(store, home, dry_run=True)
+    if preview["changes"]:
+        authorize(args, interactive, preview)
+    if getattr(args, "dry_run", False):
+        return preview
+    return autoupdate.turn_off(store, home)
+
+
 def resync_integrations(home, store):
     """After rollback/recover, drop integrations whose agents no longer have crow-behaviour."""
     try:
@@ -387,6 +456,12 @@ def run(args):
         return integrations_command(args, home, store, interactive)
     if args.command == "progress":
         return progress_command(args, home)
+    if args.command == "mode":
+        return mode_command(args, home)
+    if args.command == "events":
+        return events_command(args, home, store)
+    if args.command == "autoupdate":
+        return autoupdate_command(args, home, store, interactive)
     if args.command in ("status", "doctor"):
         targets = scope(args, home, read=True)
         rows = store.status(targets)
@@ -399,9 +474,15 @@ def run(args):
         except CrowError as exc:
             ui = [{"integration": "*", "status": "unsafe", "note": str(exc)}]
         result = {"installations": rows, "guides": guides, "integrations": ui, "pending_transactions": pending,
-                  "activation_verified": False, "reload_hint": "Peça ao host para recarregar/listar skills; reinicie a sessão se necessário."}
+                  "mode": hook.read_mode(home), "activation_verified": False,
+                  "reload_hint": "Peça ao host para recarregar/listar skills; reinicie a sessão se necessário."}
+        try:
+            result["autoupdate"] = autoupdate.status(store, home) if global_view else None
+        except CrowError as exc:
+            result["autoupdate"] = {"enabled": None, "healthy": False, "error": exc.code}
         if args.command == "doctor":
-            result.update(healthy=not pending and all(r["status"] not in ("modified", "missing", "unsafe", "external_link") for r in rows + guides),
+            result.update(healthy=not pending and all(r["status"] not in ("modified", "missing", "unsafe", "external_link") for r in rows + guides)
+                          and (result["autoupdate"] or {}).get("healthy", True) is not False,
                           agents=inventory(home))
         return result
     if args.command in ("rollback", "recover"):
@@ -505,6 +586,11 @@ def emit(command, data, machine):
     elif command == "progress":
         if data is not None:
             print(data["text"] or "crow: nenhuma execução registrada neste diretório.")
+    elif command == "mode":
+        print(data["indicator"] + " — " + data["applies"])
+    elif command == "events":
+        if data is not None:
+            print(data["text"] if "text" in data else "\n".join(json.dumps(e, ensure_ascii=False) for e in data["events"]))
     elif command == "list":
         print("Fonte: " + data["revision"])
         for item in data["skills"]: