@andespindola/crow-skills 0.1.0 → 0.4.0

package/README.md

@@ -2,6 +2,8 @@
 
 Skills com escopo explícito, conhecimento especializado preservado e fluxos comuns reutilizáveis.
 
+**Versão 0.4.0** ([mudanças](CHANGELOG.md)): crow-behaviour com paridade de orquestração, ledger de progresso, `crow-skills progress` e integrações de interface por agente.
+
 **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).
 
 ## Uso
@@ -12,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. 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/`), 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).
 
 Exemplos:
 - Plataforma nova: `crow-platform` coordena; `crow-discovery` e `crow-spec` definem o que falta; as especialistas implementam/verificam por fatia.
@@ -25,9 +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.
+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. 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.
 
 ```sh
+npm install -g @andespindola/crow-skills@0.4.0
+crow-skills progress
 ./bin/crow-skills list
 ./bin/crow-skills install crow-behaviour --agents claude,codex --global --dry-run
 ./bin/crow-skills install crow-behaviour --agents claude,codex --global --yes --json
@@ -36,7 +40,7 @@ O pacote de cada skill é somente sua pasta em `skills/`. O [CLI crow-skills](do
 
 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, auto-update ou reconfiguração de agentes. 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 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.
 
 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/catalog.json

@@ -12,7 +12,7 @@
     {
       "name": "crow-behaviour",
       "title": "Atuação coordenada",
-      "description": "Aplique um modo de atuação orientado a orquestração, profundidade e verificação em tarefas substantivas. Decomponha, delegue com as capacidades reais do agente e sintetize evidências. Em conversa ou ajustes triviais, responda diretamente; não simule agentes nem altere permissões.",
+      "description": "Use PROATIVAMENTE, sem o usuário pedir, sempre que a tarefa for substantiva — multi-etapa, com exploração/decisões, mexendo em vários arquivos ou componentes, ou exigindo verificação antes de entregar (implementar uma feature, refatorar, depurar, auditar, revisar, migrar, pesquisar a fundo). Ao ativar: decomponha o trabalho, delegue com as capacidades reais do runtime, verifique de forma adversarial e sintetize evidências. NÃO ative em conversa, explicação curta ou ajuste trivial/local — nesses casos responda direto. Não simule agentes nem altere permissões.",
       "role": "coordinator",
       "owns": "execution-ledger",
       "next": []

package/crow_skills/__init__.py

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

package/crow_skills/cli.py

@@ -1,16 +1,20 @@
 """Human and agent CLI. Noninteractive mutations require explicit --yes."""
 import argparse
 import json
+import os
 from pathlib import Path
 import sys
 
 from . import __version__
+from . import guide
+from . import integrations
+from . import progress
 from .agents import AGENTS, destinations, inventory
 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"}
+MUTATIONS = {"install", "update", "uninstall", "rollback", "recover", "guide", "integrations"}
 
 
 class Parser(argparse.ArgumentParser):
@@ -51,6 +55,19 @@ def parser():
             child.add_argument("--replace", action="store_true", help="Autorizar substituição com backup de pacote não gerenciado")
             child.add_argument("--with-handoffs", action="store_true", help="Incluir apenas handoffs diretos opcionais do catálogo")
         child.add_argument("--overwrite-modified", action="store_true", help="Autorizar backup e substituição/remoção de edições locais")
+        child.add_argument("--no-guide", action="store_true", help="Não aplicar/atualizar/remover o guia do agente (--global)")
+        child.add_argument("--no-integrations", action="store_true",
+                           help="Não aplicar/remover as integrações de interface (status line, tmux) em --global")
+    child = sub.add_parser("guide", parents=[common], help="Instruções gerenciadas para o agente usar as skills instaladas")
+    child.add_argument("action", choices=("install", "status", "uninstall"))
+    child.add_argument("--replace", action="store_true", help="Autorizar backup e substituição de conteúdo não gerenciado no caminho do guia")
+    child.add_argument("--overwrite-modified", action="store_true", help="Autorizar backup e substituição/remoção de guia editado")
+    child = sub.add_parser("integrations", parents=[common], help="Status line/tmux que mostram a execução crow-behaviour ativa")
+    child.add_argument("action", choices=("install", "status", "uninstall"))
+    child = sub.add_parser("progress", parents=[common], help="Painel de progresso da execução crow-behaviour (ledger, barras, tokens)")
+    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")
     for name in ("rollback", "recover"):
         child = sub.add_parser(name, parents=[common])
         child.add_argument("--transaction", required=name == "rollback")
@@ -113,6 +130,197 @@ def relationship_view(source, name, store, targets):
             "meaning": "Handoffs e overlays são complementos opcionais, não dependências nem ordem automática de execução."}
 
 
+def guide_command(args, home, store, interactive):
+    if getattr(args, "project", None) or getattr(args, "dest", None):
+        raise CrowError("unsupported_guide", "Guias só têm mecanismo nativo verificado no escopo do usuário; use --global. "
+                        "Escopo de projeto e --dest não são suportados.")
+    agents = getattr(args, "agents", None)
+    if args.action == "status":
+        rows = guide.status(store, home, guide.select(agents) if agents else list(guide.MECHANISMS))
+        return {"guides": rows, "pending_transactions": [t["id"] for t in store.pending()], "activation_verified": False}
+    if not getattr(args, "global_scope", False):
+        raise CrowError("usage", "guide " + args.action + " exige --global explícito (único escopo verificado).")
+    if not agents and interactive:
+        agents = prompt("Agentes separados por vírgula (" + ",".join(guide.MECHANISMS) + "):")
+    selected = guide.select(agents)
+    source = None
+    if args.action == "install":
+        source = Source(getattr(args, "source", DEFAULT_SOURCE), getattr(args, "ref", "HEAD"), getattr(args, "fetch", False))
+    plan = guide.plan(store, args.action, selected, home, source, args.replace, args.overwrite_modified)
+    summary = {"changes": plan["changes"], "revision": source.revision if source else None,
+               "additive": True, "activation_verified": False}
+    if getattr(args, "dry_run", False):
+        summary["preview"] = plan["previews"]
+    if plan["items"]:
+        authorize(args, interactive, summary)
+    txid = None if getattr(args, "dry_run", False) else guide.apply(store, plan, home)
+    return {**summary, "transaction": txid, "dry_run": getattr(args, "dry_run", False),
+            "applied": not getattr(args, "dry_run", False),
+            "reload_hint": ("Somente preview; nada gravado." if getattr(args, "dry_run", False) else
+                            "Abra uma sessão nova do CLI para carregar as instruções; o carregamento não é verificado por este comando.")}
+
+
+GUIDE_HINT = (" O guia do agente é aplicado junto com as skills em --global; revise e use --replace ou "
+              "--overwrite-modified conforme o caso, ou --no-guide para não alterar o guia. Nada foi alterado.")
+
+
+def guide_sync(args, home, store, command, targets, plan, source):
+    """Plan the guide changes that follow a skills plan, before anything is written.
+
+    Returns (report, guide plan or None). A refused guide raises, so the command
+    fails as a whole with no partial state.
+    """
+    report = {"changes": [], "skipped": [], "transaction": None}
+    selected = [a for t in targets for a in t["agents"]]
+    if getattr(args, "no_guide", False):
+        report["skipped"] = [{"agent": a, "reason": "--no-guide: guia não alterado."} for a in selected]
+        return report, None
+    if getattr(args, "project", None) or getattr(args, "dest", None):
+        report["skipped"] = [{"agent": a, "reason": "Sem mecanismo de guia verificado fora do escopo do usuário; "
+                              "guia aplicado só com --global."} for a in selected]
+        return report, None
+    for agent in selected:
+        if agent not in guide.MECHANISMS:
+            report["skipped"].append({"agent": agent, "reason": guide.UNVERIFIED.get(agent, "Sem mecanismo de guia verificado.")})
+    state = guide.load_state(store)
+    touched = {}
+    for item in plan["items"]:
+        added, removed = touched.setdefault(os.path.abspath(item["target"]), (set(), set()))
+        (removed if item["new"] is None else added).add(item["name"])
+    actions, skills_after = {}, {}
+    for agent, mech in guide.MECHANISMS.items():
+        path = os.path.abspath(destinations(agent, home)[0]["path"])
+        record = state["guides"].get(agent)
+        if agent not in selected and not (record and path in touched):
+            continue
+        added, removed = touched.get(path, (set(), set()))
+        after = sorted((set(guide.managed_skills(agent, home, store)) | added) - removed)
+        if mech["kind"] == "toml" and guide.tomllib is None:
+            report["skipped"].append({"agent": agent, "reason": "Python 3.11+ (tomllib) é necessário para editar config.toml; guia não alterado."})
+        elif "crow-behaviour" in after and (record or command != "uninstall"):
+            actions[agent], skills_after[agent] = "install", after
+        elif record and "crow-behaviour" in removed:
+            actions[agent] = "uninstall"
+        elif record and "crow-behaviour" not in after:
+            report["skipped"].append({"agent": agent, "reason": "crow-behaviour ausente; guia mantido. Confira crow-skills guide status."})
+        elif not record and command != "uninstall":
+            report["skipped"].append({"agent": agent, "reason": "crow-behaviour não ficará instalada para " + agent + "; guia não aplicado."})
+    if not actions:
+        return report, None
+    if source is None and "install" in actions.values():
+        source = Source(getattr(args, "source", DEFAULT_SOURCE), getattr(args, "ref", "HEAD"))
+    try:
+        gplan = guide.plan(store, actions, list(actions), home, source, getattr(args, "replace", False),
+                           args.overwrite_modified, skills_after)
+    except CrowError as exc:
+        raise CrowError(exc.code, str(exc) + GUIDE_HINT) from exc
+    report["changes"] = gplan["changes"]
+    report["revision"] = source.revision if source else None
+    if getattr(args, "dry_run", False):
+        report["preview"] = gplan["previews"]
+    return report, gplan
+
+
+def apply_chain(store, plan, gplan, home):
+    """Skills first, then the guide; a failed guide rolls the skills back."""
+    txid = store.apply(plan)
+    if gplan is None:
+        return txid, None
+    try:
+        return txid, guide.apply(store, gplan, home, linked=txid)
+    except (Exception, KeyboardInterrupt) as exc:
+        if txid:
+            try:
+                store.rollback(txid)
+            except CrowError as inner:
+                raise CrowError("partial_state", "Guia falhou e as skills da transação " + txid + " não puderam ser desfeitas (" +
+                                str(inner) + "). Execute crow-skills recover; ele desfaz o guia e as skills ligadas.") from exc
+        raise
+
+
+def behaviour_agents(home, store, plan=None):
+    """Agents with a verified guide mechanism that have crow-behaviour after the plan applies."""
+    touched = {}
+    for item in (plan or {}).get("items", []):
+        added, removed = touched.setdefault(os.path.abspath(item["target"]), (set(), set()))
+        (removed if item["new"] is None else added).add(item["name"])
+    result = []
+    for agent in guide.MECHANISMS:
+        path = os.path.abspath(destinations(agent, home)[0]["path"])
+        added, removed = touched.get(path, (set(), set()))
+        if "crow-behaviour" in (set(guide.managed_skills(agent, home, store)) | added) - removed:
+            result.append(agent)
+    return result
+
+
+def integrations_preview(args, home, store, plan):
+    """Integrations follow the skills in --global unless --no-integrations ("disabled" otherwise)."""
+    if getattr(args, "no_integrations", False):
+        return {"changes": [], "skipped": [{"integration": "*", "reason": "--no-integrations: integrações não alteradas."}], "disabled": True}
+    if getattr(args, "project", None) or getattr(args, "dest", None):
+        return {"changes": [], "skipped": [{"integration": "*", "reason": "Integrações de interface só existem no escopo do usuário (--global)."}],
+                "disabled": True}
+    return integrations.sync(store, home, integration_agents(args, home, store, plan), dry_run=True)
+
+
+def integration_agents(args, home, store, plan=None, selected=None):
+    """Agents whose integrations should exist: crow-behaviour present and either selected now
+    or already integrated (like the guide, a shared-root install does not opt codex in)."""
+    if selected is None:
+        selected = [a for t in destinations(getattr(args, "agents", None), home) for a in t["agents"]] if getattr(args, "agents", None) else []
+    try:
+        owners = {a for name in integrations.load_state(store)["integrations"] for a in integrations.OWNERS.get(name, ())}
+    except CrowError:
+        owners = set()
+    return [a for a in behaviour_agents(home, store, plan) if a in selected or a in owners]
+
+
+def integrations_command(args, home, store, interactive):
+    if args.action == "status":
+        return {"integrations": integrations.status(store, home)}
+    if not getattr(args, "global_scope", False):
+        raise CrowError("usage", "integrations " + args.action + " exige --global explícito (único escopo suportado).")
+    wanted = []
+    if args.action == "install":
+        wanted = integration_agents(args, home, store) if getattr(args, "agents", None) else behaviour_agents(home, store)
+    if args.action == "install" and not wanted:
+        raise CrowError("guide_requires_skill", "crow-behaviour não está instalada para nenhum agente; instale antes: "
+                        "crow-skills install crow-behaviour --agents claude --global --yes")
+    preview = integrations.sync(store, home, wanted, dry_run=True)
+    if preview["changes"]:
+        authorize(args, interactive, preview)
+    if getattr(args, "dry_run", False):
+        return {**preview, "applied": False}
+    return {**integrations.sync(store, home, wanted), "applied": True}
+
+
+def progress_command(args, home):
+    cwd = getattr(args, "cwd", None) or os.getcwd()
+    if args.watch:
+        if getattr(args, "json", False):
+            raise CrowError("usage", "--watch não combina com --json.")
+        progress.watch(cwd, home, args.run)
+        return None
+    run, usage = progress.snapshot(cwd, home, args.run)
+    data = progress.as_json(run, usage)
+    data["text"] = progress.render(run, usage, color=False, unicode=progress.unicode_ok()) if run else None
+    return data
+
+
+def resync_integrations(home, store):
+    """After rollback/recover, drop integrations whose agents no longer have crow-behaviour."""
+    try:
+        if integrations.load_state(store)["integrations"]:
+            integrations.sync(store, home, integration_agents(None, home, store, selected=[]))
+    except CrowError:
+        pass  # Reported by status/doctor; never turns a completed rollback into a failure.
+
+
+def linked_guides(store, txid):
+    """Committed guide transactions that completed the given skills transaction."""
+    return [t["id"] for t in store.transactions() if t.get("kind") == "guide" and t.get("linked") == txid and t["phase"] == "committed"]
+
+
 def run(args):
     if args.version:
         return {"version": __version__}
@@ -121,18 +329,32 @@ def run(args):
     home = checked(getattr(args, "home", Path.home()))
     store = Store(home)
     interactive = sys.stdin.isatty() and not getattr(args, "non_interactive", False) and not getattr(args, "json", False)
-    if getattr(args, "fetch", False) and (getattr(args, "dry_run", False) or args.command not in ("install", "update", "list", "info", "related")):
+    if getattr(args, "fetch", False) and (getattr(args, "dry_run", False) or args.command not in ("install", "update", "list", "info", "related", "guide")):
         raise CrowError("usage", "--fetch requer um comando com fonte e não pode ser combinado com --dry-run.")
     if args.command == "agents":
         return {"agents": inventory(home), "note": "Detecção por PATH/diretórios não comprova carregamento da skill."}
+    if args.command == "guide":
+        return guide_command(args, home, store, interactive)
+    if args.command == "integrations":
+        return integrations_command(args, home, store, interactive)
+    if args.command == "progress":
+        return progress_command(args, home)
     if args.command in ("status", "doctor"):
         targets = scope(args, home, read=True)
         rows = store.status(targets)
         pending = [t["id"] for t in store.pending()]
-        result = {"installations": rows, "pending_transactions": pending,
+        global_view = not (getattr(args, "project", None) or getattr(args, "dest", None))
+        names = [n.strip() for n in getattr(args, "agents", "").split(",")] if getattr(args, "agents", None) else list(guide.MECHANISMS)
+        guides = guide.status(store, home, names) if global_view else []
+        try:
+            ui = integrations.status(store, home) if global_view else []
+        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."}
         if args.command == "doctor":
-            result.update(healthy=not pending and all(r["status"] not in ("modified", "missing", "unsafe") for r in rows), agents=inventory(home))
+            result.update(healthy=not pending and all(r["status"] not in ("modified", "missing", "unsafe") for r in rows + guides),
+                          agents=inventory(home))
         return result
     if args.command in ("rollback", "recover"):
         if any(getattr(args, k, None) for k in ("agents", "dest", "project", "global_scope")):
@@ -142,12 +364,29 @@ def run(args):
         expected = ("prepared", "restoring") if args.command == "recover" else ("committed",)
         if any(t["phase"] not in expected for t in transactions):
             raise CrowError("invalid_transaction", "Transação incompatível com a operação.")
-        summary = {"transactions": [{"id": t["id"], "targets": list(t["before"])} for t in transactions]}
+        # install/update/uninstall chain a skills transaction and a guide transaction
+        # (journal field "linked"). Undo both together: the guide first on rollback;
+        # on recover, an interrupted guide also undoes the skills it completed.
+        follow = []
+        if args.command == "rollback":
+            before_ids = [g for txid in ids for g in linked_guides(store, txid)]
+            ids, transactions = before_ids + ids, [store.journal(t) for t in before_ids] + transactions
+        else:
+            follow = [t["linked"] for t in transactions if t.get("linked")
+                      and store.journal(t["linked"])["phase"] == "committed"]
+        view = lambda t: {"id": t["id"], "kind": t.get("kind", "skills"),
+                          "targets": [i["path"] for i in t["items"]] if t.get("kind") == "guide" else list(t["before"])}
+        summary = {"transactions": [view(t) for t in transactions]}
+        if follow:
+            summary["then_rollback"] = [view(store.journal(t)) for t in follow]
         if transactions:
             authorize(args, interactive, summary)
         if not getattr(args, "dry_run", False):
             for txid in ids:
                 store.rollback(txid, recovery=args.command == "recover")
+            for txid in follow:
+                store.rollback(txid)
+            resync_integrations(home, store)
         return {**summary, "dry_run": getattr(args, "dry_run", False), "applied": not getattr(args, "dry_run", False)}
     source = None
     if args.command != "uninstall":
@@ -185,12 +424,23 @@ def run(args):
             source.require(name)
             names.extend(n for n in source.catalog[name]["next"] if n not in names)
     plan = store.plan(args.command, names, targets, source, getattr(args, "replace", False), args.overwrite_modified)
+    guides, gplan = guide_sync(args, home, store, args.command, targets, plan, source)
+    ui = integrations_preview(args, home, store, plan)
     summary = {"changes": plan["changes"], "revision": source.revision if source else None,
                "relationships": {n: source.related(n) for n in names} if source else {},
-               "handoffs_are_optional": True, "activation_verified": False}
-    if plan["items"]:
+               "guides": guides, "integrations": ui, "handoffs_are_optional": True, "activation_verified": False}
+    if plan["items"] or (gplan and gplan["items"]) or ui.get("changes"):
         authorize(args, interactive, summary)
-    txid = None if getattr(args, "dry_run", False) else store.apply(plan)
+    txid = None
+    if not getattr(args, "dry_run", False):
+        txid, guides["transaction"] = apply_chain(store, plan, gplan, home)
+        if not ui.get("disabled"):
+            # Best effort after the skills/guide transactions; a refusal is reported, never undoes them.
+            try:
+                summary["integrations"] = integrations.sync(store, home, integration_agents(args, home, store))
+            except (CrowError, OSError) as exc:
+                summary["integrations"] = {"changes": [], "skipped": [{"integration": "*", "reason": "Integrações não aplicadas (" +
+                                                                       (str(exc) or "falha de gravação") + "); skills e guia mantidos."}]}
     return {**summary, "transaction": txid, "dry_run": getattr(args, "dry_run", False),
             "applied": not getattr(args, "dry_run", False),
             "reload_hint": ("Somente preview; nada instalado." if getattr(args, "dry_run", False) else
@@ -201,6 +451,9 @@ def emit(command, data, machine):
     envelope = {"schema_version": 1, "ok": True, "command": command, "data": data}
     if machine:
         print(json.dumps(envelope, ensure_ascii=False, separators=(",", ":")))
+    elif command == "progress":
+        if data is not None:
+            print(data["text"] or "crow: nenhuma execução registrada neste diretório.")
     elif command == "list":
         print("Fonte: " + data["revision"])
         for item in data["skills"]: