cctx-cli 1.5.1__tar.gz → 1.6.0__tar.gz

{cctx_cli-1.5.1 → cctx_cli-1.6.0}/CHANGELOG.md

@@ -2,6 +2,65 @@
 
 <!-- version list -->
 
+## v1.6.0 (2026-06-10)
+
+### Bug Fixes
+
+- Harvest — preview_patches dedup per (target, heading) not heading-only
+  ([#108](https://github.com/jacquardlabs/cctx/pull/108),
+  [`afa964c`](https://github.com/jacquardlabs/cctx/commit/afa964c68b445030e1fafe9f41c67a0de4afcd2d))
+
+- Harvest — shorten local-import comment under 100-char line limit
+  ([#108](https://github.com/jacquardlabs/cctx/pull/108),
+  [`afa964c`](https://github.com/jacquardlabs/cctx/commit/afa964c68b445030e1fafe9f41c67a0de4afcd2d))
+
+### Documentation
+
+- Harvest — correct misleading local-import comment
+  ([#108](https://github.com/jacquardlabs/cctx/pull/108),
+  [`afa964c`](https://github.com/jacquardlabs/cctx/commit/afa964c68b445030e1fafe9f41c67a0de4afcd2d))
+
+- Spec deviation note (sync returns patches) + PRODUCT.md cross-agent emit row
+  ([#108](https://github.com/jacquardlabs/cctx/pull/108),
+  [`afa964c`](https://github.com/jacquardlabs/cctx/commit/afa964c68b445030e1fafe9f41c67a0de4afcd2d))
+
+### Features
+
+- Cctx harvest --emit — cross-agent layer to AGENTS.md (#82)
+  ([#108](https://github.com/jacquardlabs/cctx/pull/108),
+  [`afa964c`](https://github.com/jacquardlabs/cctx/commit/afa964c68b445030e1fafe9f41c67a0de4afcd2d))
+
+- Cli — harvest --emit / --sync cross-agent emit
+  ([#108](https://github.com/jacquardlabs/cctx/pull/108),
+  [`afa964c`](https://github.com/jacquardlabs/cctx/commit/afa964c68b445030e1fafe9f41c67a0de4afcd2d))
+
+- Harvest — EMIT_TARGETS + retarget_patches (fan-out to AGENTS.md)
+  ([#108](https://github.com/jacquardlabs/cctx/pull/108),
+  [`afa964c`](https://github.com/jacquardlabs/cctx/commit/afa964c68b445030e1fafe9f41c67a0de4afcd2d))
+
+- Harvest — sync_managed_sections backfills CLAUDE.md into emit target
+  ([#108](https://github.com/jacquardlabs/cctx/pull/108),
+  [`afa964c`](https://github.com/jacquardlabs/cctx/commit/afa964c68b445030e1fafe9f41c67a0de4afcd2d))
+
+- Models — MANAGED_HEADINGS registry for cctx-owned CLAUDE.md sections
+  ([#108](https://github.com/jacquardlabs/cctx/pull/108),
+  [`afa964c`](https://github.com/jacquardlabs/cctx/commit/afa964c68b445030e1fafe9f41c67a0de4afcd2d))
+
+### Testing
+
+- Emit + sync idempotency through apply_patches
+  ([#108](https://github.com/jacquardlabs/cctx/pull/108),
+  [`afa964c`](https://github.com/jacquardlabs/cctx/commit/afa964c68b445030e1fafe9f41c67a0de4afcd2d))
+
+- End-to-end fan-out to both targets; spec: reconcile sync error contract
+  ([#108](https://github.com/jacquardlabs/cctx/pull/108),
+  [`afa964c`](https://github.com/jacquardlabs/cctx/commit/afa964c68b445030e1fafe9f41c67a0de4afcd2d))
+
+- Lock MANAGED_HEADINGS registry to recommender templates
+  ([#108](https://github.com/jacquardlabs/cctx/pull/108),
+  [`afa964c`](https://github.com/jacquardlabs/cctx/commit/afa964c68b445030e1fafe9f41c67a0de4afcd2d))
+
+
 ## v1.5.1 (2026-06-10)
 
 ### Bug Fixes

{cctx_cli-1.5.1 → cctx_cli-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cctx-cli
-Version: 1.5.1
+Version: 1.6.0
 Summary: Diagnose Claude Code sessions — find what went wrong, what it cost, and what to add to CLAUDE.md
 Author: Jacquard Labs
 License-Expression: MIT

{cctx_cli-1.5.1 → cctx_cli-1.6.0}/PRODUCT.md

@@ -76,6 +76,7 @@ Six commands (`ls`, `autopsy`, `harvest`, `watch`, `trace`, `export`). No comman
 | Memory-hygiene depth | `harvest --check` + `--check-severity` | v1.4.0 (M13) |
 | Live session badges | `cctx ls` | unreleased |
 | Live session detection, early idle exit | `cctx watch` | unreleased |
+| Cross-agent emit | `cctx harvest --emit agents [--sync]` | M15; mirror CLAUDE.md sections to AGENTS.md — unreleased |
 
 ### Pattern classifiers (v1.4.0)
 

{cctx_cli-1.5.1 → cctx_cli-1.6.0}/cctx/__init__.py

@@ -1,3 +1,3 @@
 """cctx: profile, debug, and optimize Claude Code and Agent SDK sessions."""
 
-__version__ = "1.5.1"
+__version__ = "1.6.0"

{cctx_cli-1.5.1 → cctx_cli-1.6.0}/cctx/cli.py

@@ -23,6 +23,7 @@ from cctx.agents import live_sessions as _live_sessions
 from cctx.diagnostician import aggregate
 from cctx.diagnostician.patterns import project_specific
 from cctx.discovery import complete_project as _complete_project
+from cctx.harvest import EMIT_TARGETS
 from cctx.models import KIND_LABEL, AggregateReport
 from cctx.parsers.claude_code import parse_session
 from cctx.recommender import claude_md
@@ -570,6 +571,22 @@ def trace(target: Path | None, latest: bool) -> None:
     show_default=True,
     help="Minimum severity that causes --check to exit 1.",
 )
+@click.option(
+    "--emit",
+    "emit_targets",
+    multiple=True,
+    type=click.Choice(list(EMIT_TARGETS)),
+    help="Also write applicable patches to another agent's instruction file "
+         "(e.g. AGENTS.md). Repeatable.",
+)
+@click.option(
+    "--sync",
+    "sync_mode",
+    is_flag=True,
+    default=False,
+    help="With --emit: also mirror already-harvested cctx-managed sections "
+         "from CLAUDE.md into the emit target.",
+)
 def harvest(
     target: Path,
     since: str | None,
@@ -578,9 +595,20 @@ def harvest(
     target_dir: Path | None,
     check_mode: bool,
     check_severity: str,
+    emit_targets: tuple[str, ...],
+    sync_mode: bool,
 ) -> None:
     """Apply autopsy patches to CLAUDE.md."""
-    from cctx.harvest import apply_patches, check_claude_md, preview_patches
+    from cctx.harvest import (
+        apply_patches,
+        check_claude_md,
+        preview_patches,
+        retarget_patches,
+        sync_managed_sections,
+    )
+
+    if sync_mode and not emit_targets:
+        raise click.UsageError("--sync requires --emit.")
 
     if check_mode:
         from cctx.harvest import CheckSeverity
@@ -626,6 +654,13 @@ def harvest(
         diagnosis = claude_md.generate(diagnosis)
         patches = diagnosis.patches
 
+    base = patches
+    for t in emit_targets:
+        emitted = retarget_patches(base, t)
+        if sync_mode:
+            emitted = emitted + sync_managed_sections(resolved_dir, t)
+        patches = patches + emitted
+
     if not patches:
         render_harvest_results([], dry_run=dry_run)
         return

{cctx_cli-1.5.1 → cctx_cli-1.6.0}/cctx/harvest.py

@@ -13,6 +13,7 @@ Layering rules (MUST respect):
 """
 from __future__ import annotations
 
+import dataclasses
 import re
 from collections import defaultdict
 from dataclasses import dataclass
@@ -20,6 +21,8 @@ from enum import Enum
 from pathlib import Path
 from typing import TYPE_CHECKING
 
+from cctx.models import MANAGED_HEADING_PREFIX, MANAGED_HEADINGS
+
 if TYPE_CHECKING:
     from cctx.models import Patch
 
@@ -105,6 +108,70 @@ def _is_supported_target(patch: Patch) -> bool:
 # Public API
 # ---------------------------------------------------------------------------
 
+# Maps an --emit target name to the destination filename. Single place to add
+# future targets (Cursor, Windsurf, Copilot) when demand exists.
+EMIT_TARGETS: dict[str, str] = {
+    "agents": "AGENTS.md",
+}
+
+
+def retarget_patches(patches: list[Patch], emit_target: str) -> list[Patch]:
+    """Clone CLAUDE.md-targeted patches to the emit target's file.
+
+    Only patches whose target_file is exactly "CLAUDE.md" are emitted —
+    .claude/rules/ and .claude/skills/ patches are Claude Code-specific and do
+    not translate to other agents. Returns clones; inputs are unmodified.
+    """
+    dest = EMIT_TARGETS[emit_target]
+    return [
+        dataclasses.replace(p, target_file=dest)
+        for p in patches
+        if p.target_file == "CLAUDE.md"
+    ]
+
+
+# Reverse map: exact managed heading -> the FindingKind that owns it.
+_HEADING_TO_KIND = {heading: kind for kind, heading in MANAGED_HEADINGS.items()}
+
+
+def sync_managed_sections(target_dir: Path, emit_target: str) -> list[Patch]:
+    """Build synthetic patches mirroring CLAUDE.md's cctx-managed sections.
+
+    Reads CLAUDE.md in target_dir, keeps sections whose heading is an exact
+    MANAGED_HEADINGS value or starts with MANAGED_HEADING_PREFIX, and returns
+    one Patch per kept section targeting the emit file. Returns [] if CLAUDE.md
+    is absent. The CLI routes these through preview_patches / apply_patches, so
+    idempotency and dry-run come for free from the existing machinery.
+    """
+    from cctx.models import FindingKind, Patch  # runtime use (Patch is TYPE_CHECKING-only above)
+
+    claude_md = target_dir / "CLAUDE.md"
+    if not claude_md.exists():
+        return []
+
+    dest = EMIT_TARGETS[emit_target]
+    content = claude_md.read_text(encoding="utf-8")
+    patches: list[Patch] = []
+
+    for heading, body in _parse_sections(content):
+        is_fixed = heading in _HEADING_TO_KIND
+        is_prefixed = heading.startswith(MANAGED_HEADING_PREFIX)
+        if not (is_fixed or is_prefixed):
+            continue
+
+        kind = _HEADING_TO_KIND[heading] if is_fixed else FindingKind.PROJECT_PATTERN
+        diff_lines = [heading] + body.splitlines()
+        unified_diff = "\n".join(f"+{line}" for line in diff_lines)
+        patches.append(Patch(
+            target_file=dest,
+            description=heading,
+            unified_diff=unified_diff,
+            finding_kind=kind,
+            evidence_summary="synced from CLAUDE.md",
+        ))
+
+    return patches
+
 
 def apply_patch(patch: Patch, target_dir: Path) -> ApplyResult:
     """Apply one patch. Never raises — errors go into ApplyResult(status=ERROR)."""
@@ -161,8 +228,10 @@ def apply_patch(patch: Patch, target_dir: Path) -> ApplyResult:
 def preview_patches(patches: list[Patch], target_dir: Path) -> list[ApplyResult]:
     """Compute what would happen without writing. Returns APPLIED or SKIPPED."""
     results = []
-    # Track fingerprints already "seen" within this preview run (idempotency)
-    seen_fingerprints: set[str] = set()
+    # Track (target_path, fingerprint) pairs already "seen" within this preview
+    # run (idempotency). Keyed by file so the same heading in two different
+    # target files is correctly treated as two independent patches.
+    seen_fingerprints: set[tuple[Path, str]] = set()
 
     for patch in patches:
         target_path = target_dir / patch.target_file
@@ -181,7 +250,8 @@ def preview_patches(patches: list[Patch], target_dir: Path) -> list[ApplyResult]
 
         content = target_path.read_text(encoding="utf-8") if target_path.exists() else ""
 
-        if fp is not None and (_already_present(content, fp) or fp in seen_fingerprints):
+        already_seen = fp is not None and (target_path, fp) in seen_fingerprints
+        if fp is not None and (_already_present(content, fp) or already_seen):
             results.append(ApplyResult(
                 patch=patch,
                 status=ApplyStatus.SKIPPED,
@@ -190,7 +260,7 @@ def preview_patches(patches: list[Patch], target_dir: Path) -> list[ApplyResult]
             ))
         else:
             if fp is not None:
-                seen_fingerprints.add(fp)
+                seen_fingerprints.add((target_path, fp))
             results.append(ApplyResult(
                 patch=patch,
                 status=ApplyStatus.APPLIED,

{cctx_cli-1.5.1 → cctx_cli-1.6.0}/cctx/models.py

@@ -184,6 +184,22 @@ KIND_LABEL: dict[FindingKind, str] = {
     FindingKind.PROJECT_PATTERN: "PROJECT PATTERN",
 }
 
+# Maps FindingKind to the exact ## heading emitted by its recommender patch
+# template. Single source of truth for "which CLAUDE.md sections cctx owns."
+# harvest.py imports this (never reaches into recommender/) so emit/sync can
+# identify cctx-managed sections without depending on the patch generator.
+MANAGED_HEADINGS: dict[FindingKind, str] = {
+    FindingKind.RETRY_LOOP:    "## Retry discipline",
+    FindingKind.SCOPE_CREEP:   "## Scope discipline",
+    FindingKind.STALE_CONTEXT: "## Context hygiene",
+    FindingKind.TOOL_THRASH:   "## Tool-call discipline",
+    FindingKind.DEAD_END:      "## Exploration discipline",
+}
+
+# Project-specific patterns use a heading that embeds tool+key, so the managed
+# section is identified by prefix rather than exact match.
+MANAGED_HEADING_PREFIX: str = "## Project-specific: "
+
 
 class Severity(str, Enum):
     HIGH   = "high"

{cctx_cli-1.5.1 → cctx_cli-1.6.0}/docs/superpowers/specs/2026-06-09-cross-agent-emit-design.md

@@ -88,12 +88,21 @@ Clones patches suitable for emission:
   reach here given the above filter, but stated explicitly for clarity).
 - Returns clones via `dataclasses.replace(patch, target_file=EMIT_TARGETS[emit_target])`.
 
-### `sync_managed_sections(target_dir, emit_target) -> list[ApplyResult]`
+### `sync_managed_sections(target_dir, emit_target) -> list[Patch]`
+
+> **Implementation deviation (2026-06-10):** This function returns
+> `list[Patch]` rather than applying patches inline (the original draft returned
+> `list[ApplyResult]` and called `apply_patch` itself). The CLI appends these
+> patches to the same list it routes through `preview_patches` / `apply_patches`.
+> Returning patches keeps `--dry-run` write-free by construction and matches the
+> codebase's "CLI decides preview vs. apply" layering — applying inline could not
+> preview, contradicting the `--dry-run` requirement and `test_dry_run_no_writes`.
 
 1. Reads `CLAUDE.md` from `target_dir`. Returns empty list if absent.
 2. Calls `_parse_sections(content)` (already in `harvest.py`).
 3. Keeps sections whose heading is exactly in `MANAGED_HEADINGS.values()` OR
-   starts with `MANAGED_HEADING_PREFIX`.
+   starts with `MANAGED_HEADING_PREFIX`. The leading `("(preamble)", …)` pair
+   matches neither branch and is skipped.
 4. For each kept section, constructs a synthetic `Patch` with:
    - `target_file = EMIT_TARGETS[emit_target]`
    - `unified_diff = "\n".join(f"+{line}" for line in [heading] + body.splitlines())`
@@ -102,8 +111,10 @@ Clones patches suitable for emission:
      `FindingKind.PROJECT_PATTERN` for `## Project-specific: …` prefixed headings
    - `description = heading`
    - `evidence_summary = "synced from CLAUDE.md"`
-5. Applies each synthetic patch via `apply_patch`, which handles idempotency
-   via `_already_present` (the `## Heading` line is the fingerprint).
+5. Returns the list of synthetic patches. The CLI routes them through the
+   existing `preview_patches` / `apply_patches` machinery, which handles
+   idempotency via `_already_present` (the `## Heading` line is the fingerprint)
+   and dry-run preview without writing.
 
 ---
 
@@ -143,8 +154,13 @@ under their full path.
 ## Error contract
 
 - Never raises. All failures return `ApplyResult(status=ERROR, message=...)`.
-- `--sync` with no CLAUDE.md: returns `[]` (not an error), logged as a
-  single `SKIPPED` line: "CLAUDE.md not found — nothing to sync."
+- `--sync` with no CLAUDE.md: `sync_managed_sections` returns `[]` (not an
+  error). Because it returns patches rather than applying inline (see the
+  deviation note above), there is no `SKIPPED` line for the missing file — the
+  empty result simply contributes nothing, and if no other patches exist the CLI
+  prints its standard "No patches to apply." message. (The original draft
+  emitted a "CLAUDE.md not found — nothing to sync." line; that belonged to the
+  inline-apply design and no longer applies.)
 - Emit target directory is created by `apply_patch`'s existing `parent.mkdir`.
 
 ---

{cctx_cli-1.5.1 → cctx_cli-1.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cctx-cli"
-version = "1.5.1"
+version = "1.6.0"
 description = "Diagnose Claude Code sessions — find what went wrong, what it cost, and what to add to CLAUDE.md"
 readme = "README.md"
 requires-python = ">=3.10"

cctx_cli-1.6.0/tests/test_harvest_emit.py

@@ -0,0 +1,204 @@
+"""Tests for cctx/harvest.py cross-agent emit (M15) and the managed-heading registry."""
+from __future__ import annotations
+
+
+def test_managed_headings_cover_the_five_diagnostic_kinds():
+    from cctx.models import MANAGED_HEADINGS, FindingKind
+    assert MANAGED_HEADINGS == {
+        FindingKind.RETRY_LOOP:    "## Retry discipline",
+        FindingKind.SCOPE_CREEP:   "## Scope discipline",
+        FindingKind.STALE_CONTEXT: "## Context hygiene",
+        FindingKind.TOOL_THRASH:   "## Tool-call discipline",
+        FindingKind.DEAD_END:      "## Exploration discipline",
+    }
+
+
+def test_managed_heading_prefix_is_project_specific():
+    from cctx.models import MANAGED_HEADING_PREFIX
+    assert MANAGED_HEADING_PREFIX == "## Project-specific: "
+
+
+def test_registry_matches_templates():
+    """Each MANAGED_HEADINGS value equals the first '+##' line of its template diff."""
+    from cctx.models import MANAGED_HEADINGS
+    from cctx.recommender.claude_md import _TEMPLATES
+    for kind, heading in MANAGED_HEADINGS.items():
+        assert kind in _TEMPLATES, f"{kind} missing from _TEMPLATES"
+        _desc, diff_body, _target = _TEMPLATES[kind]
+        first_line = diff_body.splitlines()[0]
+        assert first_line == f"+{heading}", (
+            f"{kind}: template heading {first_line!r} != registry {('+' + heading)!r}"
+        )
+
+
+def _patch(target_file="CLAUDE.md", heading="## Retry discipline"):
+    from cctx.models import FindingKind, Patch
+    return Patch(
+        target_file=target_file,
+        description="desc",
+        unified_diff=f"+{heading}\n+\n+body line",
+        finding_kind=FindingKind.RETRY_LOOP,
+        evidence_summary="ev",
+    )
+
+
+def test_retarget_clones_claude_md_patches_to_agents():
+    from cctx.harvest import retarget_patches
+    out = retarget_patches([_patch()], "agents")
+    assert len(out) == 1
+    assert out[0].target_file == "AGENTS.md"
+    assert out[0].unified_diff == _patch().unified_diff
+
+
+def test_retarget_excludes_non_claude_md_patches():
+    from cctx.harvest import retarget_patches
+    rules_patch = _patch(target_file=".claude/rules/foo.md")
+    out = retarget_patches([_patch(), rules_patch], "agents")
+    assert len(out) == 1
+    assert out[0].target_file == "AGENTS.md"
+
+
+def test_emit_targets_has_agents():
+    from cctx.harvest import EMIT_TARGETS
+    assert EMIT_TARGETS["agents"] == "AGENTS.md"
+
+
+def test_sync_returns_managed_sections_only(tmp_path):
+    from cctx.harvest import sync_managed_sections
+    (tmp_path / "CLAUDE.md").write_text(
+        "# Project\n\n"
+        "## Retry discipline\n\nRetry rule body.\n\n"
+        "## My hand-written section\n\nNot managed by cctx.\n\n"
+        "## Project-specific: Bash(pnpm install)\n\nUse pnpm --filter.\n",
+        encoding="utf-8",
+    )
+    patches = sync_managed_sections(tmp_path, "agents")
+    headings = {p.unified_diff.splitlines()[0] for p in patches}
+    assert "+## Retry discipline" in headings
+    assert "+## Project-specific: Bash(pnpm install)" in headings
+    assert "+## My hand-written section" not in headings
+    assert all(p.target_file == "AGENTS.md" for p in patches)
+
+
+def test_sync_finding_kind_reverse_lookup(tmp_path):
+    from cctx.harvest import sync_managed_sections
+    from cctx.models import FindingKind
+    (tmp_path / "CLAUDE.md").write_text(
+        "## Context hygiene\n\nbody\n\n"
+        "## Project-specific: Bash(x)\n\nbody\n",
+        encoding="utf-8",
+    )
+    patches = sync_managed_sections(tmp_path, "agents")
+    by_heading = {p.unified_diff.splitlines()[0]: p.finding_kind for p in patches}
+    assert by_heading["+## Context hygiene"] is FindingKind.STALE_CONTEXT
+    assert by_heading["+## Project-specific: Bash(x)"] is FindingKind.PROJECT_PATTERN
+
+
+def test_sync_no_claude_md_returns_empty(tmp_path):
+    from cctx.harvest import sync_managed_sections
+    assert sync_managed_sections(tmp_path, "agents") == []
+
+
+def test_emit_apply_then_reapply_is_idempotent(tmp_path):
+    from cctx.harvest import ApplyStatus, apply_patches, retarget_patches
+    patches = retarget_patches([_patch()], "agents")
+    first = apply_patches(patches, tmp_path)
+    assert [r.status for r in first] == [ApplyStatus.APPLIED]
+    second = apply_patches(patches, tmp_path)
+    assert [r.status for r in second] == [ApplyStatus.SKIPPED]
+    text = (tmp_path / "AGENTS.md").read_text(encoding="utf-8")
+    assert text.count("## Retry discipline") == 1
+
+
+def test_sync_apply_then_reapply_is_idempotent(tmp_path):
+    from cctx.harvest import ApplyStatus, apply_patches, sync_managed_sections
+    (tmp_path / "CLAUDE.md").write_text(
+        "## Retry discipline\n\nRetry rule body.\n", encoding="utf-8"
+    )
+    patches = sync_managed_sections(tmp_path, "agents")
+    apply_patches(patches, tmp_path)
+    second = apply_patches(patches, tmp_path)
+    assert all(r.status is ApplyStatus.SKIPPED for r in second)
+    text = (tmp_path / "AGENTS.md").read_text(encoding="utf-8")
+    assert text.count("## Retry discipline") == 1
+
+
+def test_preview_same_heading_different_targets_both_applied(tmp_path):
+    """Two patches with the same heading but different target files must both
+    preview as APPLIED — dedup is per-(file, heading), not heading-only."""
+    from cctx.harvest import ApplyStatus, preview_patches
+    from cctx.models import FindingKind, Patch
+    diff = "+## Retry discipline\n+\n+body"
+    patches = [
+        Patch("CLAUDE.md", "d", diff, FindingKind.RETRY_LOOP, "e"),
+        Patch("AGENTS.md", "d", diff, FindingKind.RETRY_LOOP, "e"),
+    ]
+    statuses = [r.status for r in preview_patches(patches, tmp_path)]
+    assert statuses == [ApplyStatus.APPLIED, ApplyStatus.APPLIED]
+
+
+def test_preview_same_heading_same_target_dedups(tmp_path):
+    """Two patches with the same heading AND same target: second is SKIPPED."""
+    from cctx.harvest import ApplyStatus, preview_patches
+    from cctx.models import FindingKind, Patch
+    diff = "+## Retry discipline\n+\n+body"
+    patches = [
+        Patch("AGENTS.md", "d", diff, FindingKind.RETRY_LOOP, "e"),
+        Patch("AGENTS.md", "d", diff, FindingKind.RETRY_LOOP, "e"),
+    ]
+    statuses = [r.status for r in preview_patches(patches, tmp_path)]
+    assert statuses == [ApplyStatus.APPLIED, ApplyStatus.SKIPPED]
+
+
+def test_sync_without_emit_errors(tmp_path):
+    from click.testing import CliRunner  # noqa: I001
+    from cctx.cli import cli
+    (tmp_path / "CLAUDE.md").write_text("## Retry discipline\n\nbody\n", encoding="utf-8")
+    runner = CliRunner()
+    result = runner.invoke(cli, [
+        "harvest", str(tmp_path), "--since", "7",
+        "--sync", "--target-dir", str(tmp_path),
+    ])
+    assert result.exit_code != 0
+    assert "--sync" in result.output and "--emit" in result.output
+
+
+def test_sync_dry_run_writes_nothing(tmp_path):
+    from click.testing import CliRunner  # noqa: I001
+    from cctx.cli import cli
+    (tmp_path / "CLAUDE.md").write_text("## Retry discipline\n\nbody\n", encoding="utf-8")
+    runner = CliRunner()
+    result = runner.invoke(cli, [
+        "harvest", str(tmp_path), "--since", "7",
+        "--emit", "agents", "--sync", "--dry-run",
+        "--target-dir", str(tmp_path),
+    ])
+    assert result.exit_code == 0
+    assert not (tmp_path / "AGENTS.md").exists()
+
+
+def test_sync_apply_creates_agents_md(tmp_path):
+    from click.testing import CliRunner  # noqa: I001
+    from cctx.cli import cli
+    (tmp_path / "CLAUDE.md").write_text("## Retry discipline\n\nbody\n", encoding="utf-8")
+    runner = CliRunner()
+    result = runner.invoke(cli, [
+        "harvest", str(tmp_path), "--since", "7",
+        "--emit", "agents", "--sync", "--apply",
+        "--target-dir", str(tmp_path),
+    ])
+    assert result.exit_code == 0
+    assert (tmp_path / "AGENTS.md").exists()
+    assert "## Retry discipline" in (tmp_path / "AGENTS.md").read_text(encoding="utf-8")
+
+
+def test_emit_applies_both_targets(tmp_path):
+    """End-to-end fan-out: a CLAUDE.md patch and its retargeted clone both land,
+    one in CLAUDE.md and one in AGENTS.md (mirrors the CLI's base+retarget flow)."""
+    from cctx.harvest import ApplyStatus, apply_patches, retarget_patches
+    base = [_patch()]  # one CLAUDE.md patch
+    combined = base + retarget_patches(base, "agents")
+    results = apply_patches(combined, tmp_path)
+    assert all(r.status is ApplyStatus.APPLIED for r in results)
+    assert "## Retry discipline" in (tmp_path / "CLAUDE.md").read_text(encoding="utf-8")
+    assert "## Retry discipline" in (tmp_path / "AGENTS.md").read_text(encoding="utf-8")