code-coordinator 0.5.645__tar.gz → 0.5.647__tar.gz

{code_coordinator-0.5.645 → code_coordinator-0.5.647}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.645
+Version: 0.5.647
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.645 → code_coordinator-0.5.647}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.645
+Version: 0.5.647
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.645 → code_coordinator-0.5.647}/code_coordinator.egg-info/SOURCES.txt

@@ -545,6 +545,7 @@ tests/test_cli_gate_a.py
 tests/test_cli_inject_board_less.py
 tests/test_cli_install_drift.py
 tests/test_cli_install_skills.py
+tests/test_cli_issue_close_wrong_repo.py
 tests/test_cli_issue_comment.py
 tests/test_cli_issue_create_label.py
 tests/test_cli_issue_reopen.py

{code_coordinator-0.5.645 → code_coordinator-0.5.647}/code_coordinator.egg-info/scm_file_list.json

@@ -572,6 +572,7 @@
     "tests/test_cli_inject_board_less.py",
     "tests/test_cli_install_drift.py",
     "tests/test_cli_install_skills.py",
+    "tests/test_cli_issue_close_wrong_repo.py",
     "tests/test_cli_issue_comment.py",
     "tests/test_cli_issue_create_label.py",
     "tests/test_cli_issue_reopen.py",

code_coordinator-0.5.647/code_coordinator.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.5.647",
+  "distance": 0,
+  "node": "g60a9fa87d838723613ea07d8d30f1e8a08914471",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-17"
+}

{code_coordinator-0.5.645 → code_coordinator-0.5.647}/coord/agent.py

@@ -6425,10 +6425,24 @@ PLAIN_RUNNER_LOG_TAIL_CHARS = 8000
 
 
 def _tail_text(text: str, limit: int = PLAIN_RUNNER_LOG_TAIL_CHARS) -> str:
-    """The last *limit* characters of *text*, with a marker when truncated."""
+    """Keep the first and last portions of *text* when it exceeds *limit*.
+
+    Split 1/4 head + 3/4 tail: biased toward the tail (summary markers,
+    exit status) but enough head to capture the first test failure or
+    compiler error — which is the output that matters most for a fix
+    worker and is otherwise lost when later stages pile on compilation
+    noise (#3715).
+    """
     if len(text) <= limit:
         return text
-    return f"...[truncated, {len(text) - limit} earlier chars omitted]...\n{text[-limit:]}"
+    head_budget = limit // 4
+    tail_budget = limit - head_budget
+    omitted = len(text) - limit
+    return (
+        f"{text[:head_budget]}\n"
+        f"...[truncated, {omitted} chars omitted — first {head_budget} + last {tail_budget} shown]...\n"
+        f"{text[-tail_budget:]}"
+    )
 
 
 @dataclass(frozen=True)

{code_coordinator-0.5.645 → code_coordinator-0.5.647}/coord/commands/issues.py

@@ -572,6 +572,221 @@ def issue_create_cmd(
         click.echo(f"#{result['number']} ({slug}) assigned to milestone {ms_label}")
 
 
+@issue_group.command(
+    "close-wrong-repo",
+    help=(
+        "Close an issue that turns out to belong in a different repo, "
+        "filing the replacement there in the same step (#3711). REPO/ISSUE "
+        "are the issue being closed; --target is the repo (coordinator.yml "
+        "name or owner/repo slug) the fix actually belongs in.\n\n"
+        "A worker that reaches this conclusion should run this instead of "
+        "just saying so in its final message — closing REPO#ISSUE with a "
+        "`coord:event=wrong_repo` marker comment pointing at the new issue "
+        "is what stops further dispatch against it; a final message alone "
+        "does not.\n\n"
+        "--title/--body (or --body-file) seed the new issue — pass along "
+        "the root-cause analysis from the investigation so it isn't lost. "
+        "--reason is an optional one-line note on *why* it belongs in "
+        "--target, appended to REPO#ISSUE's closing comment. --label and "
+        "--milestone behave exactly as on `coord issue create`. A --body "
+        "without a `## Files` heading is accepted but warned about — "
+        "without it `coord drive-queue add`'s overlap prediction has "
+        "nothing to compare in-flight branches against.\n\n"
+        "Auto-queueing the new issue (`coord drive-queue add`) is left to "
+        "the operator/coordinator — this only files and links it."
+    ),
+)
+@click.argument("repo")
+@click.argument("issue", type=int)
+@click.option(
+    "--target", required=True,
+    help="Repo (coordinator.yml name or owner/repo slug) the fix belongs in.",
+)
+@click.option("--title", required=True, help="Title for the new issue in --target.")
+@click.option("--body", default=None, help="Body for the new issue in --target (markdown).")
+@click.option(
+    "--body-file",
+    type=click.Path(path_type=Path),
+    default=None,
+    help="Read the new issue's body from a file. '-' = stdin.",
+)
+@click.option(
+    "--reason", default=None,
+    help="One-line note on why this belongs in --target (appended to the close comment).",
+)
+@click.option(
+    "--label",
+    "labels",
+    multiple=True,
+    help="Label to apply to the new issue (repeatable).",
+)
+@click.option(
+    "--milestone", default=None,
+    help="Milestone (number or title) to attach the new issue to, resolved against --target.",
+)
+@click.option(
+    "--force", is_flag=True, default=False,
+    help="Close REPO#ISSUE even if it has open children (#1196).",
+)
+@_CONFIG_OPTION
+def issue_close_wrong_repo_cmd(
+    repo: str,
+    issue: int,
+    target: str,
+    title: str,
+    body: str | None,
+    body_file: Path | None,
+    reason: str | None,
+    labels: tuple[str, ...],
+    milestone: str | None,
+    force: bool,
+    config_path: Path,
+) -> None:
+    if body is not None and body_file is not None:
+        click.echo("error: --body and --body-file are mutually exclusive", err=True)
+        sys.exit(2)
+    if body_file is not None:
+        body = sys.stdin.read() if str(body_file) == "-" else Path(body_file).read_text()
+    if not body:
+        click.echo("error: provide --body or --body-file", err=True)
+        sys.exit(2)
+    if "## Files" not in body:
+        click.echo(
+            "warning: --body has no `## Files` heading — "
+            "`coord drive-queue add`'s overlap prediction won't have "
+            "anything to compare in-flight branches against for the new issue",
+            err=True,
+        )
+
+    cfg = _load_config(config_path)
+    source_slug = _resolve_repo_slug(cfg, repo)
+    source_entry = cfg.repo(repo)
+    source_name = source_entry.name if source_entry is not None else repo
+    target_slug = _resolve_repo_slug(cfg, target)
+    target_entry = cfg.repo(target)
+    target_name = target_entry.name if target_entry is not None else target
+
+    # Resolve --milestone *before* creating the issue (#3432) — creating the
+    # issue and then failing to attach it would silently reproduce the bug
+    # this closes (an issue that looks healthy but is unreachable from
+    # `coord.plans.aggregate_repo_plans`, which keys on milestone
+    # membership).
+    milestone_number: int | None = None
+    milestone_title: str | None = None
+    if milestone is not None:
+        from coord.commands.milestone import (  # noqa: PLC0415
+            MilestoneResolutionError,
+            resolve_milestone_ref,
+        )
+
+        try:
+            milestone_number, milestone_title = resolve_milestone_ref(target_slug, milestone)
+        except MilestoneResolutionError as e:
+            click.echo(f"error: {e}", err=True)
+            sys.exit(1)
+
+    # #3711: check for open children *before* filing in --target, not just
+    # at close time. `close_issue` below already refuses on open children,
+    # but by then the replacement issue would already exist — a refusal at
+    # that point followed by a natural `--force` retry would file a SECOND
+    # duplicate issue in --target rather than reusing the first. Checking
+    # here means a blocked close never creates anything in the first place.
+    if not force:
+        from coord.github_ops import has_open_children  # noqa: PLC0415
+
+        if has_open_children(source_slug, issue):
+            click.echo(
+                f"error: refusing to close {source_slug}#{issue}: it has "
+                "open children (#1196) — resolve them first, or re-run "
+                "with --force. Checked before filing in --target so a "
+                "blocked close here never leaves an orphan issue behind.",
+                err=True,
+            )
+            sys.exit(1)
+
+    from coord.comments import EVENT_WRONG_REPO  # noqa: PLC0415
+    from coord.state import add_issue_context_entry, close_issue, create_issue  # noqa: PLC0415
+
+    try:
+        result = create_issue(
+            target_name, title, body, labels=list(labels), repo_github=target_slug,
+        )
+    except Exception as e:  # noqa: BLE001
+        click.echo(f"error: filing issue in {target_slug} failed: {e}", err=True)
+        sys.exit(1)
+    new_number = result["number"]
+    click.echo(f"#{new_number} ({target_slug}) created")
+
+    if milestone_number is not None:
+        from coord.state import assign_issue_milestone  # noqa: PLC0415
+
+        try:
+            assign_issue_milestone(
+                target_name,
+                new_number,
+                milestone_number,
+                milestone_title=milestone_title,
+                repo_github=target_slug,
+            )
+        except Exception as e:  # noqa: BLE001
+            click.echo(
+                f"error: #{new_number} ({target_slug}) created but "
+                f"milestone assign failed: {e}",
+                err=True,
+            )
+            sys.exit(1)
+
+    marker = f"<!-- coord:event={EVENT_WRONG_REPO} target={target_slug} issue={new_number} -->"
+    reason_line = f"\n\n{reason}" if reason else ""
+    close_comment = (
+        f"Closing — this belongs in `{target_slug}`, filed as "
+        f"{target_slug}#{new_number}.{reason_line}\n\n{marker}"
+    )
+    try:
+        close_issue(
+            source_name, issue, comment=close_comment, repo_github=source_slug, force=force,
+        )
+    except Exception as e:  # noqa: BLE001
+        click.echo(
+            f"error: #{new_number} ({target_slug}) created but closing "
+            f"#{issue} ({source_slug}) failed: {e}\n"
+            f"Do not re-run this command to retry — it would file a "
+            f"second, duplicate issue in {target_slug}. Instead close "
+            f"{source_slug}#{issue} directly (`coord issue close {repo} "
+            f"{issue}`), referencing {target_slug}#{new_number}.",
+            err=True,
+        )
+        sys.exit(1)
+    click.echo(f"#{issue} ({source_slug}) closed as wrong-repo")
+
+    # Pinned context entries link the two issues in both directions without
+    # requiring a comment re-scrape — same hygiene as upstream_gaps._file_one.
+    # Both writes that actually matter (the new issue, the close) already
+    # landed by this point, so a daemon hiccup here must not surface as a
+    # raw traceback on an otherwise-successful command (model:
+    # coord/upstream_gaps.py's own context-entry writes).
+    try:
+        add_issue_context_entry(
+            source_name, issue,
+            f"Closed as wrong-repo — filed in {target_slug}#{new_number}.",
+            pinned=True,
+            source="wrong-repo",
+        )
+        add_issue_context_entry(
+            target_name, new_number,
+            f"Filed from {source_slug}#{issue} (closed as wrong-repo).",
+            pinned=True,
+            source="wrong-repo",
+        )
+    except Exception as e:  # noqa: BLE001
+        click.echo(
+            f"warning: {source_slug}#{issue} closed and {target_slug}#"
+            f"{new_number} filed, but recording the cross-link context "
+            f"entry failed: {e}",
+            err=True,
+        )
+
+
 @issue_group.command(
     "label",
     help=(

{code_coordinator-0.5.645 → code_coordinator-0.5.647}/coord/comments.py

@@ -98,6 +98,14 @@ EVENT_STUCK_TEST_STATE_HEALED = "stuck_test_state_healed"
 # landing a second branch) UPDATES this comment in place
 # (`coord.state.upsert_issue_comment`) rather than appending a duplicate.
 EVENT_VERIFICATION = "verification"
+# #3711: `coord issue close-wrong-repo` closes an issue whose fix belongs in
+# a different repo, filing the replacement there and linking the two with
+# this marker on the closing comment. Distinct from every event above: those
+# all narrate pipeline/worker conditions on a SINGLE issue; this one records
+# a cross-repo, cross-issue relationship (closed-here, refiled-there) so a
+# future parser can resolve `target=`/`issue=` back to the new issue without
+# re-scraping comment text.
+EVENT_WRONG_REPO = "wrong_repo"
 
 
 @dataclass

{code_coordinator-0.5.645 → code_coordinator-0.5.647}/coord/dispatch.py

@@ -332,6 +332,32 @@ gap leaves this issue unresolved, also declare `ISSUE_RESOLUTION: partial — \
 blocked on upstream (BLOCKED_ON_UPSTREAM above)`.
 """
 
+# #3711: appended to every `type="work"` briefing, alongside
+# UPSTREAM_GAP_BRIEFING_NOTE above — the worker-facing half of the
+# wrong-repo close+refile capability. `coord issue close-wrong-repo`
+# (`coord/commands/issues.py`) is the command half; without this note a
+# worker has no way to discover it (`CLAUDE.md` tells every worker the only
+# `coord` command it runs is `coord acceptance run`), so it would keep
+# reporting a wrong-repo conclusion in its final message and stopping —
+# exactly the quadraui#1554 shape (3 legs, 0 commits) this exists to end.
+WRONG_REPO_BRIEFING_NOTE = """
+
+## Wrong-repo issues — `coord issue close-wrong-repo` (#3711)
+
+If you conclude mid-investigation that this issue's fix belongs in a
+DIFFERENT repo entirely (not just a missing upstream capability — the whole
+issue is mis-targeted), don't just say so in your final message and stop:
+
+    coord issue close-wrong-repo <this-repo> <this-issue> \\
+        --target <other-repo> --title "<title>" --body "<root-cause analysis>"
+
+This closes the current issue with a `coord:event=wrong_repo` marker comment
+and files the replacement in `<other-repo>` in one step, carrying your root-
+cause analysis forward so it isn't lost — closing reads as terminal to the
+drive queue, so it also stops further dispatch against this issue. Still
+commit and push whatever is genuinely done first if you made any progress.
+"""
+
 # #3132: the addendum appended to a ``type="epic-decompose"`` dispatch's
 # briefing — see ``epic_decompose_briefing`` below. Kept as a module-level
 # constant (not inlined in the function) so a test can assert against the
@@ -1211,6 +1237,7 @@ def dispatch(
             briefing_text
             + sibling_lessons_block(proposal.repo_name, proposal.issue_number)
             + UPSTREAM_GAP_BRIEFING_NOTE
+            + WRONG_REPO_BRIEFING_NOTE
         )
     elif proposal.type == EPIC_DECOMPOSE_TYPE and proposal.issue_number:
         # #3132 review: an epic-decompose worker gets a real worktree + branch

{code_coordinator-0.5.645 → code_coordinator-0.5.647}/coord/drive.py

@@ -558,6 +558,19 @@ class DriveCounters:
     # another round" loop, and a drive that spends three rounds bouncing
     # between them has spent three rounds. Bounded by `opts.max_fix_rounds`.
     fix_rounds: int = 0
+    # #3713: branch SHA when the last fix round was dispatched.  If we
+    # re-enter `_decide_test` and the SHA is unchanged, the fix round
+    # pushed 0 commits (killed or otherwise empty) — undo the increment
+    # so an infra death doesn't spend the budget.
+    fix_round_dispatched_sha: str = ""
+    # #3713: SHA for which we already gave one free empty-fix-round retry.
+    # Prevents infinite undo→redispatch when a fix worker never pushes.
+    empty_fix_retried_sha: str = ""
+    # #3714: one-shot retry latch — the branch SHA for which we already
+    # retried the test stage before dispatching a fix round.  A first
+    # test failure at a given SHA retries the test; only the second
+    # failure at the same SHA proceeds to a fix round.
+    test_retry_sha: str = ""
     merge_attempts: int = 0
     review_dispatches: int = 0
     # #1584: bounded retry for a review WORKER that died (transient API
@@ -3190,7 +3203,7 @@ def decide(
             acceptance_gate, warnings=warnings + acceptance_gate.warnings
         )
 
-    test = _decide_test(state, opts, counters, machine)
+    test = _decide_test(state, opts, counters, machine, verifier=verifier)
     if test is not None:
         return replace(test, warnings=warnings + test.warnings)
 
@@ -3562,6 +3575,7 @@ def _decide_test(
     opts: DriveOptions,
     counters: DriveCounters,
     machine: str,
+    verifier: MergeVerifier | None = None,
 ) -> Action | None:
     """The TEST gate.  ``None`` means "passed/skipped, fall through".
 
@@ -3655,6 +3669,25 @@ def _decide_test(
                 f"   Recover: coord diagnose {state.repo} {state.issue} "
                 "--stage test --reset"
             )
+        # #3713: if we dispatched a fix round and the branch HEAD has not
+        # advanced, the fix worker pushed 0 commits (killed, timed out, or
+        # found nothing to do).  Undo the previous increment so an infra
+        # death doesn't spend the budget — but only once per SHA (the
+        # `empty_fix_retried_sha` latch prevents infinite undo→redispatch).
+        # `branch_head_sha` costs one GitHub API call — only invoked here
+        # (test failed + fix_rounds > 0), not on every poll.
+        current_sha: str | None = None
+        if (
+            counters.fix_rounds > 0
+            and counters.fix_round_dispatched_sha
+            and verifier is not None
+        ):
+            current_sha = verifier.branch_head_sha(state)
+            if current_sha and current_sha == counters.fix_round_dispatched_sha:
+                if counters.empty_fix_retried_sha != current_sha:
+                    counters.fix_rounds -= 1
+                    counters.empty_fix_retried_sha = current_sha
+
         if counters.fix_rounds >= opts.max_fix_rounds:
             return _die(
                 f"test still failing after {counters.fix_rounds} fix round(s) — "
@@ -3665,7 +3698,33 @@ def _decide_test(
                 f"   Continue by hand: coord assign --interactive --fix-of "
                 f"{state.work_aid}"
             )
+
+        # #3714: retry the test once before consuming a fix round.  A
+        # first failure at a given SHA gets one automatic retest; only the
+        # second failure at the same SHA dispatches the fix worker.  This
+        # avoids burning a fix slot on a transient / flaky failure.
+        branch_sha = current_sha or (
+            verifier.branch_head_sha(state) if verifier is not None else None
+        )
+        if branch_sha and counters.test_retry_sha != branch_sha:
+            counters.test_retry_sha = branch_sha
+            return Action(
+                kind=RUN,
+                label="TEST: failed — retrying once before fix round (#3714)",
+                command=(
+                    "diagnose", state.repo, str(state.issue),
+                    "--stage", "test", "--reset",
+                ),
+                error_message=(
+                    f"coord diagnose {state.repo} {state.issue} "
+                    "--stage test --reset failed."
+                ),
+                sleep_after=10.0,
+            )
+
         counters.fix_rounds += 1
+        # Record the branch SHA so #3713 can detect an empty fix round.
+        counters.fix_round_dispatched_sha = branch_sha or ""
         # `coord fix` gates on the assignment's legacy `smoke_test == "fail"`
         # field — which `coord test --fail` mirrors from `test_state` — and
         # dispatches a follow-up worker with `inherit_branch=True`, so the fix