claude-dev-env 4.2.0 → 7.0.0

package/.agents/skills/autoconverge/reference/stop-conditions.md

@@ -1,127 +0,0 @@
-# Stop conditions
-
-The workflow ends one of two ways: converged (PR marked ready) or blocked. A
-blocker exit returns `{ converged: false, rounds, finalSha, blocker }`, and the
-skill still runs teardown (revoke permissions, final report).
-
-## Blockers (end the run short of ready)
-
-- **Budget stop** — on `pacer=workflow`, the workflow's `budget` API is the
-  pacing signal: when a usage target is set, `converge.mjs` checks
-  `budget.remaining()` before each round and stops at the round boundary when
-  one full round (three parallel lenses + one fix commit + re-verify) does not
-  fit. The run returns `blocker: "budget"` with the run id; resume with
-  `Workflow({scriptPath, resumeFromRunId})` — completed rounds replay from the
-  journal. The workflow never starts a round the budget cannot finish: a
-  half-run round records nothing resumable and replays dirty. On
-  `pacer=portable`, stop at a tick boundary when the session cannot cover a
-  full clean tick; write handoff and resume with `/autoconverge <PR URL>`
-  ([`../../_shared/pr-loop/portable-driver.md`](../../_shared/pr-loop/portable-driver.md)).
-- **Iteration cap** — 20 loop iterations pass without a full convergence-check
-  pass. The iteration counter increments on every pass through any phase, so a
-  convergence-check gate that no round can clear (for example a `mergeable_state`
-  stuck at `blocked`, `behind`, or `unknown` that a rebase does not fix) and a
-  Copilot gate agent that keeps dying and retrying on the same HEAD both reach
-  the cap this way. `blocker` reports `iteration cap reached`.
-- **Fix stalled** — the fix lens reports no push (`pushed: false`) without
-  resolving every finding thread, returns a SHA equal to the prior HEAD on a
-  case-folded common prefix (a full or abbreviated SHA of the unchanged commit
-  both count), or returns null for a round's findings. HEAD did not move and the
-  threads were not all resolved, so the next round would re-raise the same
-  findings. The run ends with a `blocker` that names the finding count and the
-  stalled HEAD. A round whose every finding carries no GitHub thread
-  (`replyToCommentId: null` on each) and whose fix reports
-  `resolvedWithoutCommit: true` is also a stall: it moves no code and resolves no
-  thread, so re-converging on the unchanged HEAD would loop the same finding to
-  the iteration cap. The `blocker` names the in-memory finding count and the
-  stalled HEAD. An all-stale round that makes no commit but resolves every
-  finding thread (`resolvedWithoutCommit: true` with at least one thread-bearing
-  finding) is not a stall — the run re-converges on the unchanged HEAD and
-  reaches the terminal Bugbot, Copilot, Codex, and convergence gates.
-- **Static-sweep stalled** — the deterministic static sweep (`code_rules_gate.py
-  --base origin/main`, `ruff`, `mypy`, stem-matched `pytest`) raises gate or test
-  failures the fixer cannot clear on the current HEAD, so HEAD does not move. The
-  reading lenses never run on a sweep-dirty HEAD, so the run ends with a
-  static-sweep stall `blocker` naming the failure count and the stalled HEAD
-  rather than looping to the iteration cap.
-- **Mark-ready failed** — the convergence check passes but the mark-ready step
-  cannot confirm the PR left draft state (`gh pr ready` errored, or the draft
-  re-query still reports true). The workflow does not report `converged: true`;
-  the run ends with a `blocker` naming the failed ready transition.
-- **No review lens reviewed HEAD** — a round can end with no lens having reviewed
-  the HEAD three ways: the preflight resolves no SHA, every lens agent dies, or
-  every lens is down or disabled. A single such round retries on the next round.
-  Three consecutive no-lens-reviewed rounds (any mix of the three causes) reach
-  `CONFIG.maxConsecutiveNoLensRounds` and stop the run with a `blocker` that names
-  the consecutive count and only the causes that actually occurred, rather than
-  looping to the iteration cap. Any round in which at least one lens reviews the
-  HEAD resets the consecutive count.
-
-## Not a blocker (the run continues)
-
-Each reviewer-down condition below skips its own convergence-check gate. The flag and the matching `CLAUDE_REVIEWS_DISABLED` token for each condition are the single flag-per-condition table in [`../../skills-archived/reviewer-gates/SKILL.md`](../../skills-archived/reviewer-gates/SKILL.md) — "Convergence-check bypass flags"; the token carries the bypass into the mark-ready blocker hook's no-flag re-check.
-
-- **Clean-audit post bypassed** — every review lens is clean on HEAD, but the
-  environment refuses the CLEAN bugteam review post (the `post_audit_thread.py`
-  post is denied, errors, or its agent never runs). The lens results already show
-  this HEAD is clean, so the CLEAN post is a record-keeping artifact, not the
-  safety-bearing gate. The run records a `cleanAuditNote` naming the HEAD and the
-  reason, logs the bypass, and proceeds to the terminal Bugbot gate — the same
-  shape as the Bugbot-down and Copilot-down paths. The convergence check runs with
-  `--bugteam-post-blocked` so its bugteam CLEAN-review gate is skipped and the run
-  closes on the remaining signals. A round where no lens actually reviewed HEAD is
-  separate: that re-converges under the no-review-lens rule above, since no lens
-  grounded a post.
-- **Terminal Bugbot gate down or disabled** — the terminal Bugbot gate runs once
-  the internal lenses are clean. When Cursor Bugbot is off for the run (the
-  default unless `CLAUDE_REVIEWS_ENABLED` lists `bugbot`) or opted out via
-  `CLAUDE_REVIEWS_DISABLED`, the gate spawns no agent and passes to the Copilot
-  gate with `bugbotDown` set. When Bugbot is enabled but never produces a check
-  run or review after the gate poll budget, the gate returns down the same way.
-  The run continues, and the convergence check runs with `--bugbot-down` so its
-  Bugbot gate is bypassed.
-- **Copilot down or out of quota** — when Copilot posts an out-of-usage notice on
-  the current HEAD (the user who requested the review reached their quota limit)
-  rather than a code review, or surfaces no review at all after the configured cap, the
-  Copilot gate returns `down: true`. The run logs a notice, sets `copilotDown`,
-  and proceeds to the Codex gate. The later convergence check receives
-  `--copilot-down` (the Copilot review gate and the pending-requested-reviews
-  gate bypassed), then mark-ready. `copilotNote` records the bypass for the
-  final report.
-- **Terminal Codex gate skipped (no opt-in, opt-out, usage, or `codex_down`)** — the
-  conditional-required Codex gate runs after Bugbot and Copilot. When
-  `reviews_disabled.py --reviewer codex` exits 0 — which it does whenever
-  `CLAUDE_REVIEWS_ENABLED` omits `codex`, the default, and whenever
-  `CLAUDE_REVIEWS_DISABLED` lists it — the gate sets `codexDown` and advances
-  with no review. When the weekly
-  usage probe reports `percent_left` null or at/below the shared threshold
-  (`is_codex_review_required` false), the gate skips without a stamp; the
-  convergence check applies the same rule. When the codex-review wrapper
-  classifies `codex_down` — a Codex CLI error, or a review that ran past its
-  `CONFIG.codexReviewTimeoutSeconds` budget — the gate skips the same way: it sets
-  `codexDown`, records a `codexNote` so the skip stays visible in the final
-  report, clears `codexCleanAt`, and advances to `FINALIZE` (mark-ready with the
-  gate bypassed) so a Codex outage does not block convergence; Codex runs again on
-  the next convergence. A clean required run stamps `codexCleanAt` for
-  `--codex-clean-at`. Non-code-standard findings re-enter `CONVERGE` through the
-  existing fix path. Standards-only findings defer a follow-up, stamp
-  `codexCleanAt`, and advance to `FINALIZE` (no fix push).
-- **A lens agent dies** — when one parallel reading lens returns null (a terminal
-  agent failure), the round proceeds on the surviving lenses. A real defect it
-  would have caught surfaces in a later round or at the convergence check. A dead
-  terminal Bugbot gate agent (null result) is a retry rather than an approval, so
-  the gate re-runs on the same HEAD rather than treating a dead agent as a clean
-  Bugbot verdict.
-- **Every lens agent dies (a single round)** — when all three parallel reading
-  lenses return null in the same round, the round is a failure, not a clean: the
-  workflow posts no CLEAN bugteam artifact and does not advance to the terminal
-  gates. It re-resolves HEAD and retries on the next round. This is a
-  no-lens-reviewed round, so consecutive occurrences are bounded by the
-  no-review-lens cap in the blockers above, not just the iteration cap.
-
-## User stop
-
-Stopping the background workflow (`TaskStop`, or the user halting the run) ends
-it where it stands. Re-launching `/autoconverge` starts a fresh run; the
-workflow journal allows resuming the prior run from its last completed step with
-`Workflow({ scriptPath, resumeFromRunId })`.

package/.agents/skills/autoconverge/test_portable_pacer_gate.py

@@ -1,54 +0,0 @@
-"""Contract checks: autoconverge selects a portable pacer when Workflow is absent."""
-
-from __future__ import annotations
-
-import re
-from pathlib import Path
-
-SKILL_ROOT = Path(__file__).resolve().parent
-SKILL_MARKDOWN_PATH = SKILL_ROOT / "SKILL.md"
-MULTI_PR_MARKDOWN_PATH = SKILL_ROOT / "reference" / "multi-pr.md"
-PORTABLE_DRIVER_PATH = (
-    SKILL_ROOT.parent / "_shared" / "pr-loop" / "portable-driver.md"
-)
-
-SELECT_CONVERGE_PACER_SCRIPT = "select_converge_pacer.py"
-PACER_PORTABLE_TOKEN = "pacer=portable"
-PACER_WORKFLOW_TOKEN = "pacer=workflow"
-ABORT_ONLY_PHRASE = "autoconverge requires the Workflow tool"
-PORTABLE_DRIVER_DOC = "portable-driver.md"
-PORTABLE_DRIVER_LINK_PATTERN = re.compile(
-    r"\((?P<relative>(?:\.\./)+_shared/pr-loop/portable-driver\.md)\)"
-)
-
-
-def test_skill_selects_pacer_and_forbids_abort_only_workflow() -> None:
-    skill_text = SKILL_MARKDOWN_PATH.read_text(encoding="utf-8")
-    assert SELECT_CONVERGE_PACER_SCRIPT in skill_text
-    assert PACER_PORTABLE_TOKEN in skill_text
-    assert PACER_WORKFLOW_TOKEN in skill_text
-    assert PORTABLE_DRIVER_DOC in skill_text
-    assert ABORT_ONLY_PHRASE not in skill_text
-
-
-def test_skill_portable_driver_links_resolve_on_disk() -> None:
-    skill_text = SKILL_MARKDOWN_PATH.read_text(encoding="utf-8")
-    all_relative_links = PORTABLE_DRIVER_LINK_PATTERN.findall(skill_text)
-    assert all_relative_links, "SKILL.md must link portable-driver.md"
-    for each_relative_link in all_relative_links:
-        resolved_path = (SKILL_MARKDOWN_PATH.parent / each_relative_link).resolve()
-        assert resolved_path.is_file(), (
-            f"portable-driver link must resolve on disk: "
-            f"{each_relative_link} -> {resolved_path}"
-        )
-        assert resolved_path == PORTABLE_DRIVER_PATH.resolve()
-
-
-def test_multi_pr_documents_portable_launch_and_teardown() -> None:
-    multi_pr_text = MULTI_PR_MARKDOWN_PATH.read_text(encoding="utf-8")
-    assert PACER_PORTABLE_TOKEN in multi_pr_text
-    assert "Do **not** call `Workflow`" in multi_pr_text or (
-        "Do not call `Workflow`" in multi_pr_text
-    )
-    assert "pacer=portable" in multi_pr_text
-    assert PORTABLE_DRIVER_DOC in multi_pr_text

package/.agents/skills/autoconverge/workflow/.claude/CLAUDE.md

@@ -1 +0,0 @@
-@../AGENTS.md

package/.agents/skills/autoconverge/workflow/AGENTS.md

@@ -1 +0,0 @@
-

package/.agents/skills/autoconverge/workflow/aggregate_runs.py

@@ -1,371 +0,0 @@
-"""Merge every autoconverge run journal for one PR into a single combined journal."""
-
-import argparse
-import json
-import os
-import re
-import shutil
-import stat
-import sys
-from collections.abc import Callable
-from dataclasses import dataclass
-from pathlib import Path
-from typing import TextIO
-
-import convergence_summary
-import render_report
-from autoconverge_report_constants.render_report_constants import (
-    ARGS_FIELD_OWNER,
-    ARGS_FIELD_PR_NUMBER,
-    ARGS_FIELD_REPO,
-    COMBINED_RUN_ID_PREFIX,
-    JOURNAL_FIELD_ARGS,
-    JOURNAL_FIELD_RESULT,
-    JOURNAL_FIELD_RUN_ID,
-    JOURNAL_FIELD_TIMESTAMP,
-    JOURNAL_FIELD_WORKFLOW_NAME,
-    JOURNAL_FIELD_WORKFLOW_PROGRESS,
-    JOURNAL_SIBLING_SUBAGENTS,
-    JOURNAL_SIBLING_WORKFLOWS,
-    LABEL_RESOLVE_HEAD,
-    ONEXC_PYTHON_MAJOR_VERSION,
-    ONEXC_PYTHON_MINOR_VERSION,
-    PROGRESS_FIELD_AGENT_ID,
-    PROGRESS_FIELD_LABEL,
-    PROJECTS_DIR_NAME,
-    RESULT_FIELD_FINAL_SHA,
-    SUMMARY_DETAIL_MAX_CHARS,
-    WORKFLOW_NAME_AUTOCONVERGE,
-)
-
-
-@dataclass(frozen=True)
-class AggregateResult:
-    """The combined journal plus the aggregated inputs a closing report needs."""
-
-    combined_journal_path: Path
-    findings: list[dict]
-    fix_summaries: list[str]
-    round_count: int
-    final_sha: str
-
-
-def _parse_args_object(journal: dict) -> dict:
-    """Return the journal's args as a dict, parsing a JSON string when needed.
-
-    Args:
-        journal: A parsed run-journal object.
-
-    Returns:
-        The args object as a dict, or an empty dict when absent or unparseable.
-    """
-    raw_args = journal.get(JOURNAL_FIELD_ARGS, "")
-    if isinstance(raw_args, dict):
-        return raw_args
-    try:
-        parsed = json.loads(raw_args)
-    except (ValueError, TypeError):
-        return {}
-    return parsed if isinstance(parsed, dict) else {}
-
-
-def _resolve_projects_root(seed_journal_path: Path) -> Path:
-    """Return the projects directory that contains the seed run journal.
-
-    Args:
-        seed_journal_path: Path to one of the PR's wf_<runId>.json journals.
-
-    Returns:
-        The nearest ancestor directory named 'projects', or the seed's
-        four-levels-up ancestor when no such ancestor exists.
-    """
-    for each_ancestor in seed_journal_path.parents:
-        if each_ancestor.name == PROJECTS_DIR_NAME:
-            return each_ancestor
-    return seed_journal_path.parents[3]
-
-
-def _discover_pr_runs(
-    projects_root: Path, owner: str, repo: str, pr_number: int
-) -> list[tuple[Path, dict]]:
-    """Return every autoconverge (journal path, journal) pair for the PR, oldest first.
-
-    Args:
-        projects_root: The projects directory holding all run trees.
-        owner: The PR's repository owner.
-        repo: The PR's repository name.
-        pr_number: The PR number.
-
-    Returns:
-        A timestamp-sorted list of (journal path, parsed journal) pairs.
-    """
-    runs: list[tuple[Path, dict]] = []
-    for each_journal_path in projects_root.glob("*/*/workflows/wf_*.json"):
-        try:
-            journal = json.loads(each_journal_path.read_text(encoding="utf-8"))
-        except (ValueError, OSError):
-            continue
-        if journal.get(JOURNAL_FIELD_WORKFLOW_NAME) != WORKFLOW_NAME_AUTOCONVERGE:
-            continue
-        args_object = _parse_args_object(journal)
-        matches_pr = (
-            args_object.get(ARGS_FIELD_OWNER) == owner
-            and args_object.get(ARGS_FIELD_REPO) == repo
-            and args_object.get(ARGS_FIELD_PR_NUMBER) == pr_number
-        )
-        if matches_pr:
-            runs.append((each_journal_path, journal))
-    runs.sort(key=lambda pair: pair[1].get(JOURNAL_FIELD_TIMESTAMP, ""))
-    return runs
-
-
-def discover_pr_journals(
-    projects_root: Path, owner: str, repo: str, pr_number: int
-) -> list[Path]:
-    """Return every autoconverge journal path for the PR, oldest first.
-
-    Args:
-        projects_root: The projects directory holding all run trees.
-        owner: The PR's repository owner.
-        repo: The PR's repository name.
-        pr_number: The PR number.
-
-    Returns:
-        A timestamp-sorted list of journal paths matching the PR.
-    """
-    return [
-        path
-        for path, _journal in _discover_pr_runs(projects_root, owner, repo, pr_number)
-    ]
-
-
-def _retry_after_chmod(
-    remove_func: Callable[[str], None], failing_path: str, *_exc_info: object
-) -> None:
-    """Clear the Windows read-only bit on a path, then retry the removal that failed.
-
-    Args:
-        remove_func: The os removal call rmtree was attempting when it failed.
-        failing_path: The path the failed removal call could not delete.
-        _exc_info: The exception or exc_info tuple the rmtree handler passes.
-    """
-    os.chmod(failing_path, stat.S_IWRITE)
-    remove_func(failing_path)
-
-
-def _select_rmtree_handler_keyword() -> dict[str, Callable[..., None]]:
-    """Return the rmtree retry-handler keyword argument for the running Python.
-
-    Returns:
-        A single-entry dict using the 'onexc' keyword on the Python versions that
-        accept it and 'onerror' on the earlier versions that do not.
-    """
-    onexc_required_version = (ONEXC_PYTHON_MAJOR_VERSION, ONEXC_PYTHON_MINOR_VERSION)
-    if sys.version_info >= onexc_required_version:
-        return {"onexc": _retry_after_chmod}
-    return {"onerror": _retry_after_chmod}
-
-
-def _force_remove(target_path: Path) -> None:
-    """Remove a directory tree, clearing the Windows read-only bit on failure.
-
-    Args:
-        target_path: The directory tree to remove when it exists.
-    """
-    if not target_path.exists():
-        return
-    handler_keyword = _select_rmtree_handler_keyword()
-    if "onexc" in handler_keyword:
-        shutil.rmtree(target_path, onexc=_retry_after_chmod)
-        return
-    shutil.rmtree(target_path, onerror=_retry_after_chmod)
-
-
-def aggregate_pr_journals(
-    seed_journal_path: Path, owner: str, repo: str, pr_number: int, work_dir: Path
-) -> AggregateResult:
-    """Merge every autoconverge journal for the PR into one combined journal.
-
-    Args:
-        seed_journal_path: One of the PR's run journals, used to locate the rest.
-        owner: The PR's repository owner.
-        repo: The PR's repository name.
-        pr_number: The PR number.
-        work_dir: A directory the combined run tree is written under.
-
-    Returns:
-        An AggregateResult carrying the combined journal path, the deduped
-        findings, the fix summaries, the resolve-head round count, and the
-        final commit sha drawn from the latest run's result.
-    """
-    projects_root = _resolve_projects_root(seed_journal_path)
-    runs = _discover_pr_runs(projects_root, owner, repo, pr_number)
-
-    combined_run_id = f"{COMBINED_RUN_ID_PREFIX}{pr_number}"
-    dest_base = work_dir / combined_run_id
-    _force_remove(dest_base)
-    combined_workflows_dir = dest_base / JOURNAL_SIBLING_WORKFLOWS
-    combined_workflows_dir.mkdir(parents=True)
-    combined_agents_dir = (
-        dest_base
-        / JOURNAL_SIBLING_SUBAGENTS
-        / JOURNAL_SIBLING_WORKFLOWS
-        / combined_run_id
-    )
-    combined_agents_dir.mkdir(parents=True)
-
-    combined_progress: list[dict] = []
-    final_sha = ""
-    latest_timestamp = ""
-    for each_journal_path, each_journal in runs:
-        source_agents_dir = (
-            each_journal_path.parent.parent
-            / JOURNAL_SIBLING_SUBAGENTS
-            / JOURNAL_SIBLING_WORKFLOWS
-            / each_journal_path.stem
-        )
-        for each_entry in each_journal.get(JOURNAL_FIELD_WORKFLOW_PROGRESS, []):
-            agent_id = each_entry.get(PROGRESS_FIELD_AGENT_ID)
-            if agent_id:
-                source_transcript = source_agents_dir / f"agent-{agent_id}.jsonl"
-                if source_transcript.exists():
-                    shutil.copy(
-                        source_transcript,
-                        combined_agents_dir / f"agent-{agent_id}.jsonl",
-                    )
-            combined_progress.append(each_entry)
-        result_block = each_journal.get(JOURNAL_FIELD_RESULT) or {}
-        if result_block.get(RESULT_FIELD_FINAL_SHA):
-            final_sha = result_block[RESULT_FIELD_FINAL_SHA]
-        timestamp = each_journal.get(JOURNAL_FIELD_TIMESTAMP, "")
-        if timestamp > latest_timestamp:
-            latest_timestamp = timestamp
-
-    round_count = sum(
-        1
-        for each_entry in combined_progress
-        if each_entry.get(PROGRESS_FIELD_LABEL) == LABEL_RESOLVE_HEAD
-    )
-    combined_journal = {
-        JOURNAL_FIELD_RUN_ID: combined_run_id,
-        JOURNAL_FIELD_TIMESTAMP: latest_timestamp,
-        JOURNAL_FIELD_WORKFLOW_NAME: WORKFLOW_NAME_AUTOCONVERGE,
-        JOURNAL_FIELD_ARGS: json.dumps(
-            {
-                ARGS_FIELD_OWNER: owner,
-                ARGS_FIELD_REPO: repo,
-                ARGS_FIELD_PR_NUMBER: pr_number,
-            }
-        ),
-        JOURNAL_FIELD_RESULT: {RESULT_FIELD_FINAL_SHA: final_sha},
-        JOURNAL_FIELD_WORKFLOW_PROGRESS: combined_progress,
-    }
-    combined_journal_path = combined_workflows_dir / f"{combined_run_id}.json"
-    combined_journal_path.write_text(json.dumps(combined_journal), encoding="utf-8")
-
-    run_data = render_report.load_run_data(combined_journal_path)
-    findings = [
-        {
-            "severity": each_finding.severity,
-            "category": each_finding.category,
-            "file": each_finding.file,
-            "line": each_finding.line,
-            "title": each_finding.title,
-            "detail": (each_finding.detail or "")[:SUMMARY_DETAIL_MAX_CHARS],
-        }
-        for each_finding in run_data.all_distinct_findings
-    ]
-    fix_summaries = [
-        each_fix.summary
-        for each_fix in run_data.fix_by_round.values()
-        if each_fix.summary
-    ]
-    return AggregateResult(
-        combined_journal_path=combined_journal_path,
-        findings=findings,
-        fix_summaries=fix_summaries,
-        round_count=round_count,
-        final_sha=final_sha,
-    )
-
-
-def main(out_stream: TextIO = sys.stdout, err_stream: TextIO = sys.stderr) -> int:
-    """Aggregate a PR's journals, write the summary prompt, print the combined facts.
-
-    Args:
-        out_stream: Stream the result JSON is written to on success.
-        err_stream: Stream error messages are written to.
-
-    Returns:
-        Exit code (0 on success, 1 on argument error).
-    """
-    argument_parser = argparse.ArgumentParser(
-        description="Aggregate every autoconverge journal for a PR into one journal."
-    )
-    argument_parser.add_argument(
-        "--journal", required=True, help="Path to one of the PR's wf_<runId>.json files"
-    )
-    argument_parser.add_argument("--pr", required=True, help="owner/repo#number")
-    argument_parser.add_argument(
-        "--work-dir",
-        required=True,
-        help="Directory the combined run tree is written under",
-    )
-    argument_parser.add_argument(
-        "--out-prompt",
-        required=True,
-        help="Path the summary agent prompt is written to",
-    )
-    argument_parser.add_argument(
-        "--standards-note", default=None, help="Deferred code-standard note, when any"
-    )
-    argument_parser.add_argument(
-        "--copilot-note", default=None, help="Copilot gate outage note, when any"
-    )
-    parsed_args = argument_parser.parse_args()
-
-    pr_arg_pattern = r"(?P<owner>[^/]+)/(?P<repo>[^#]+)#(?P<number>\d+)"
-    pr_match = re.fullmatch(pr_arg_pattern, parsed_args.pr)
-    if pr_match is None:
-        err_stream.write(
-            f"Invalid --pr format: {parsed_args.pr!r}. Expected owner/repo#number.\n"
-        )
-        return 1
-    owner = pr_match.group("owner")
-    repo = pr_match.group("repo")
-    pr_number = int(pr_match.group("number"))
-
-    work_dir = Path(parsed_args.work_dir)
-    work_dir.mkdir(parents=True, exist_ok=True)
-    aggregation = aggregate_pr_journals(
-        Path(parsed_args.journal).resolve(), owner, repo, pr_number, work_dir
-    )
-
-    prompt = convergence_summary.build_summary_prompt(
-        owner,
-        repo,
-        pr_number,
-        aggregation.round_count,
-        aggregation.findings,
-        aggregation.fix_summaries,
-        parsed_args.standards_note,
-        parsed_args.copilot_note,
-    )
-    Path(parsed_args.out_prompt).write_text(prompt, encoding="utf-8")
-
-    out_stream.write(
-        json.dumps(
-            {
-                "combinedJournal": str(aggregation.combined_journal_path),
-                "roundCount": aggregation.round_count,
-                "finalSha": aggregation.final_sha,
-                "findingCount": len(aggregation.findings),
-            }
-        )
-        + "\n"
-    )
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/.agents/skills/autoconverge/workflow/autoconverge_report_constants/.claude/CLAUDE.md

@@ -1 +0,0 @@
-@../AGENTS.md

package/.agents/skills/autoconverge/workflow/autoconverge_report_constants/AGENTS.md

@@ -1 +0,0 @@
-