code-coordinator 0.5.48__tar.gz → 0.5.49__tar.gz

code_coordinator-0.5.49/.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,42 @@
+---
+name: Bug report
+about: >-
+  Report broken behaviour for the test-first bug lane (docs/TEST_FIRST_BUG_LANE.md).
+  Fill in all four sections — a bug report missing any of them can't be turned
+  into a red test.
+title: ''
+labels: bug
+assignees: ''
+---
+
+<!--
+This is the test-first bug lane's intake contract (docs/TEST_FIRST_BUG_LANE.md
+"The intake contract", #1964). All four sections below are required. They are
+what a hand-authored (or agent-assisted) `contract.md` gets derived from — no
+milestone, no UX mock, no Gate-A sign-off required.
+
+`coord issue create --expected --actual --repro --evidence` renders this same
+structure from the CLI (coord/bug_intake.py is the single source of truth for
+the four headings — keep this file's headings in sync with it).
+-->
+
+## Expected behaviour
+
+<!-- What should happen, in observable terms. -->
+
+## Actual behaviour
+
+<!-- What happens instead. -->
+
+## Reproduction
+
+<!-- The shortest path to see it: exact steps/commands, starting from a clean checkout. -->
+
+## Evidence
+
+<!--
+Screenshot, wireframe, OR a reference implementation that behaves correctly
+(a sibling backend, or a prior release). A reference implementation is the
+highest-value form of evidence — it makes the expectation executable by
+construction ("X should look like Y here" is a complete specification).
+-->

{code_coordinator-0.5.48/code_coordinator.egg-info → code_coordinator-0.5.49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.48
+Version: 0.5.49
 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.48 → code_coordinator-0.5.49/code_coordinator.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.48
+Version: 0.5.49
 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.48 → code_coordinator-0.5.49}/code_coordinator.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ pyproject.toml
 .githooks/post-checkout
 .githooks/post-commit
 .githooks/post-merge
+.github/ISSUE_TEMPLATE/bug_report.md
 .github/workflows/auto-release.yml
 .github/workflows/cargo-test.yml
 .github/workflows/publish.yml
@@ -41,6 +42,7 @@ coord/board_service.py
 coord/board_wire.py
 coord/brain.py
 coord/branch_model.py
+coord/bug_intake.py
 coord/cargo_cache.py
 coord/ci_github.py
 coord/ci_store.py
@@ -440,6 +442,7 @@ tests/test_board_state.py
 tests/test_board_wire.py
 tests/test_brain.py
 tests/test_branch_model.py
+tests/test_bug_intake.py
 tests/test_build_worker_image_env_update.py
 tests/test_cargo_cache.py
 tests/test_ci_acceptance_gate_1950.py

{code_coordinator-0.5.48 → code_coordinator-0.5.49}/code_coordinator.egg-info/scm_file_list.json

@@ -7,6 +7,7 @@
     ".githooks/post-checkout",
     ".githooks/post-commit",
     ".githooks/post-merge",
+    ".github/ISSUE_TEMPLATE/bug_report.md",
     ".github/workflows/auto-release.yml",
     ".github/workflows/cargo-test.yml",
     ".github/workflows/publish.yml",
@@ -35,6 +36,7 @@
     "coord/board_wire.py",
     "coord/brain.py",
     "coord/branch_model.py",
+    "coord/bug_intake.py",
     "coord/cargo_cache.py",
     "coord/ci_github.py",
     "coord/ci_store.py",
@@ -470,6 +472,7 @@
     "tests/test_board_wire.py",
     "tests/test_brain.py",
     "tests/test_branch_model.py",
+    "tests/test_bug_intake.py",
     "tests/test_build_worker_image_env_update.py",
     "tests/test_cargo_cache.py",
     "tests/test_ci_acceptance_gate_1950.py",

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

@@ -0,0 +1,8 @@
+{
+  "tag": "0.5.49",
+  "distance": 0,
+  "node": "g06ce4a930ffe97c992bfbed693615c2504e4d2be",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-08-13"
+}

{code_coordinator-0.5.48 → code_coordinator-0.5.49}/coord/acceptance.py

@@ -53,6 +53,40 @@ def _mocks_dir(milestone_number: int) -> str:
     return f"{ACCEPTANCE_DIRNAME}/{ms_dirname(milestone_number)}/mocks"
 
 
+def issue_dirname(issue_number: int) -> str:
+    """The ``issue-NN`` directory name for a single-issue bug-lane contract
+    (docs/TEST_FIRST_BUG_LANE.md "The intake contract", #1964) — the bug
+    lane's counterpart to :func:`ms_dirname`, with no milestone in the name
+    because a bug has none.
+
+    This is purely a naming convention, not new plumbing: the manifest
+    scanner below (:func:`_manifest_paths`) globs ``*/manifest.*`` under
+    ``tests/acceptance/`` regardless of what the directory is called, so an
+    ``issue-NN/`` slice is discovered, run (``coord acceptance run --issue
+    N``), recorded (``coord acceptance record``), and injected into the
+    worker's briefing (:func:`oracle_loop_contract_block`) by the exact same
+    code path as an ``ms-NN/`` one — see ``TestOracleLoopContractBlock`` in
+    ``tests/test_acceptance.py``, which already proves the block is built
+    from whatever the owning directory happens to be named. Pinning the name
+    here just keeps every bug-lane contract in the same shape.
+    """
+    return f"issue-{issue_number}"
+
+
+def bug_contract_path(issue_number: int) -> str:
+    """Repo-relative path to *issue_number*'s single-issue bug-lane contract
+    (docs/TEST_FIRST_BUG_LANE.md "The intake contract").
+
+    Unlike :func:`gate_a_contract_path`, nothing gates dispatch on this
+    existing — a bug issue has no milestone, so there is no Gate A to block
+    on it. It is hand-authored (or agent-assisted) directly from the four
+    intake fields (:mod:`coord.bug_intake`); once it — and a
+    ``manifest.yml`` alongside it — exist, the issue behaves exactly like an
+    authored ``ms-NN`` slice to every downstream command.
+    """
+    return f"{ACCEPTANCE_DIRNAME}/{issue_dirname(issue_number)}/contract.md"
+
+
 # Mock-fixture file extension -> the driver ``kind`` it implies (the SAME
 # rule each ``AcceptanceDriverConfig.mock`` glob already encodes in
 # coordinator.yml / docs/ORACLE_LOOP.md: ``"*.screen"`` for ``tui-tuidriver``,

code_coordinator-0.5.49/coord/bug_intake.py

@@ -0,0 +1,117 @@
+"""The bug-lane intake contract (#1964, docs/TEST_FIRST_BUG_LANE.md "The
+intake contract").
+
+A bug entering the test-first bug lane carries four fields instead of the
+feature lane's UX mock:
+
+1. **Expected behaviour** — what should happen, in observable terms.
+2. **Actual behaviour** — what happens instead.
+3. **Reproduction** — the shortest path to see it.
+4. **Evidence** — screenshot, wireframe, or a reference implementation that
+   behaves correctly (a sibling backend, or a prior release).
+
+This module is the single source of truth for how those four fields are
+rendered into an issue body and parsed back out of one, so the fields
+survive as addressable sections rather than prose a later author (human or
+agent) has to re-derive:
+
+- ``coord issue create --expected/--actual/--repro/--evidence``
+  (:mod:`coord.commands.issues`) calls :func:`format_bug_report` to compose
+  the body.
+- ``.github/ISSUE_TEMPLATE/bug_report.md`` renders the exact same four
+  headings for a human filing straight through the GitHub UI — a
+  hand-authored ``contract.md`` (docs/TEST_FIRST_BUG_LANE.md, #1964
+  Deliverable 2) is written by reading that issue directly, no parsing
+  required. :func:`parse_bug_report` exists for the agent-assisted path and
+  for tooling that wants the four fields back out programmatically (e.g. a
+  future bug-contract-author briefing) — it is not on the hand-authoring
+  critical path.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+# Canonical section headings, in report order. `.github/ISSUE_TEMPLATE/
+# bug_report.md` renders these same four strings as its Markdown headings —
+# tests/test_bug_intake.py checks the template file against this module
+# directly so the two can never drift apart silently.
+EXPECTED_HEADING = "Expected behaviour"
+ACTUAL_HEADING = "Actual behaviour"
+REPRO_HEADING = "Reproduction"
+EVIDENCE_HEADING = "Evidence"
+
+#: Ordered (attribute name, heading text) pairs — single source of truth for
+#: both the render order (:func:`format_bug_report`) and the parse targets
+#: (:func:`parse_bug_report`).
+FIELDS: tuple[tuple[str, str], ...] = (
+    ("expected", EXPECTED_HEADING),
+    ("actual", ACTUAL_HEADING),
+    ("repro", REPRO_HEADING),
+    ("evidence", EVIDENCE_HEADING),
+)
+
+
+@dataclass(frozen=True)
+class BugReport:
+    """The four intake fields, parsed out of (or destined for) an issue
+    body. See module docstring for what each field means."""
+
+    expected: str
+    actual: str
+    repro: str
+    evidence: str
+
+
+def format_bug_report(*, expected: str, actual: str, repro: str, evidence: str) -> str:
+    """Render the four intake fields as a Markdown issue body, one
+    addressable ``## `` section per field, in report order.
+
+    Used by ``coord issue create --expected/--actual/--repro/--evidence`` so
+    the fields land in the issue as structured sections rather than a single
+    freeform paragraph. Round-trips through :func:`parse_bug_report`.
+    """
+    values = {
+        "expected": expected, "actual": actual, "repro": repro, "evidence": evidence,
+    }
+    parts = [
+        f"## {heading}\n\n{values[attr].strip()}" for attr, heading in FIELDS
+    ]
+    return "\n\n".join(parts) + "\n"
+
+
+def parse_bug_report(body: str) -> BugReport | None:
+    """Extract the four intake fields back out of an issue body rendered by
+    :func:`format_bug_report`, or hand-written to the same four headings.
+
+    Tolerant of heading level (``#`` through ``######``) and of surrounding
+    prose before the first heading or after the last section's text, so a
+    human-edited issue (extra context added above/below the four sections)
+    still parses. Matching is on heading text only, case-insensitively.
+
+    Returns ``None`` when any of the four sections is missing or empty — a
+    partial bug report is not a bug report the lane can act on. Callers that
+    want a best-effort partial read should not use this function.
+    """
+    heading_alts = "|".join(re.escape(heading) for _, heading in FIELDS)
+    pattern = re.compile(
+        rf"^#{{1,6}}\s*({heading_alts})\s*$", re.IGNORECASE | re.MULTILINE,
+    )
+    matches = list(pattern.finditer(body))
+    if not matches:
+        return None
+
+    by_heading: dict[str, str] = {}
+    for i, m in enumerate(matches):
+        start = m.end()
+        end = matches[i + 1].start() if i + 1 < len(matches) else len(body)
+        by_heading[m.group(1).strip().lower()] = body[start:end].strip()
+
+    kwargs: dict[str, str] = {}
+    for attr, heading in FIELDS:
+        value = by_heading.get(heading.lower())
+        if not value:
+            return None
+        kwargs[attr] = value
+    return BugReport(**kwargs)

{code_coordinator-0.5.48 → code_coordinator-0.5.49}/coord/commands/issues.py

@@ -213,7 +213,15 @@ def issue_reopen_cmd(
         "number on success.\n\n"
         "Use --body-file for long markdown bodies (avoids shell-quoting "
         "issues). '-' reads from stdin. Routes through the daemon seam so "
-        "agents never need to call `gh issue create` directly."
+        "agents never need to call `gh issue create` directly.\n\n"
+        "For a bug entering the test-first bug lane "
+        "(docs/TEST_FIRST_BUG_LANE.md, #1964), pass --expected/--actual/"
+        "--repro/--evidence instead of --body/--body-file — the four fields "
+        "land in the issue as addressable sections (coord.bug_intake) "
+        "instead of a single freeform paragraph, so a later contract.md "
+        "author (hand or agent) doesn't have to re-derive them from prose. "
+        "All four are required together, and mutually exclusive with "
+        "--body/--body-file."
     ),
 )
 @click.argument("repo")
@@ -231,6 +239,25 @@ def issue_reopen_cmd(
     multiple=True,
     help="Label to add (repeatable). The label must already exist in the repo.",
 )
+@click.option(
+    "--expected", default=None,
+    help="Bug-lane intake field: what should happen, in observable terms.",
+)
+@click.option(
+    "--actual", default=None,
+    help="Bug-lane intake field: what happens instead.",
+)
+@click.option(
+    "--repro", default=None,
+    help="Bug-lane intake field: the shortest path to see it.",
+)
+@click.option(
+    "--evidence", default=None,
+    help=(
+        "Bug-lane intake field: screenshot, wireframe, or a reference "
+        "implementation that behaves correctly."
+    ),
+)
 @_CONFIG_OPTION
 def issue_create_cmd(
     repo: str,
@@ -238,8 +265,36 @@ def issue_create_cmd(
     body: str | None,
     body_file: Path | None,
     labels: tuple[str, ...],
+    expected: str | None,
+    actual: str | None,
+    repro: str | None,
+    evidence: str | None,
     config_path: Path,
 ) -> None:
+    bug_fields = {"expected": expected, "actual": actual, "repro": repro, "evidence": evidence}
+    given_bug_fields = {k: v for k, v in bug_fields.items() if v is not None}
+    if given_bug_fields:
+        if body is not None or body_file is not None:
+            click.echo(
+                "error: --expected/--actual/--repro/--evidence are mutually "
+                "exclusive with --body/--body-file",
+                err=True,
+            )
+            sys.exit(2)
+        missing = [k for k, v in bug_fields.items() if v is None]
+        if missing:
+            click.echo(
+                "error: --expected/--actual/--repro/--evidence must all be "
+                f"given together (missing: {', '.join(f'--{m}' for m in missing)})",
+                err=True,
+            )
+            sys.exit(2)
+        from coord.bug_intake import format_bug_report  # noqa: PLC0415
+
+        body = format_bug_report(
+            expected=expected, actual=actual, repro=repro, evidence=evidence,
+        )
+
     cfg = _load_config(config_path)
     repo_entry = cfg.repo(repo)
     slug = repo_entry.github if repo_entry else repo

{code_coordinator-0.5.48 → code_coordinator-0.5.49}/docs/TEST_FIRST_BUG_LANE.md

@@ -147,9 +147,10 @@ quadraui#541 (a framework parity gap), vimcode#625's real root cause (a floating
 path-dep silently restating every snapshot), and claude-coordinator#1950 (the cadence
 hole) — three findings in three repos, from one bug.
 
-## The intake contract
+## The intake contract (#1964, shipped)
 
-An issue entering this lane carries:
+An issue entering this lane carries four fields, instead of the feature lane's
+milestone + UX mock:
 
 1. **Expected behaviour** — what should happen, in observable terms.
 2. **Actual behaviour** — what happens instead.
@@ -161,6 +162,79 @@ An issue entering this lane carries:
 implementation* is worth more than a screenshot: it makes the expectation executable
 by construction. "GTK should look like TUI here" is a complete specification.
 
+**The fields survive as structured sections, not prose.** Two front doors, both
+backed by the same four headings (`coord/bug_intake.py` is the single source of
+truth, so they can never drift apart silently):
+
+- `.github/ISSUE_TEMPLATE/bug_report.md` — a human filing straight through the
+  GitHub UI gets the four `##` sections pre-seeded.
+- `coord issue create <repo> --title "…" --expected "…" --actual "…" --repro "…"
+  --evidence "…"` — the CLI/automation front door. All four are required together
+  and mutually exclusive with `--body`/`--body-file`; `coord.bug_intake.
+  format_bug_report` renders them as one `##`-headed section apiece so a later
+  contract author (hand or agent) reads them directly off the issue instead of
+  re-deriving them from a paragraph. `coord.bug_intake.parse_bug_report` is the
+  inverse, for the agent-assisted authoring path (below).
+
+No milestone, no `coord acceptance mock`, no Gate-A sign-off happens at intake —
+those are feature-lane machinery this issue deliberately does not touch.
+
+## Single-issue contract authoring (#1964, shipped)
+
+The feature lane's contract lives at `tests/acceptance/ms-NN/contract.md`, gated by
+Gate A and keyed by a milestone number. A bug has neither. Its contract lives at:
+
+```
+tests/acceptance/issue-NN/contract.md      # coord.acceptance.bug_contract_path(NN)
+tests/acceptance/issue-NN/manifest.yml     # tests: {<test-id>: NN}
+tests/acceptance/issue-NN/<suite files>    # sealed once authored, same as ms-NN
+```
+
+`coord.acceptance.issue_dirname(NN)` / `bug_contract_path(NN)` pin the convention;
+**everything downstream already works with zero new code**, because the manifest
+scanner (`coord.acceptance._manifest_paths`) globs `*/manifest.*` under
+`tests/acceptance/` regardless of what the directory is called:
+
+- `coord acceptance run --repo R --issue NN` / `coord acceptance record --repo R
+  --issue NN --sha SHA` — already took no milestone argument (this is what the
+  issue's own framing points at: "the runner and the trust gate are reusable
+  as-is").
+- `coord.acceptance.oracle_loop_contract_block` — the "🔒 Oracle-loop acceptance
+  contract" block prepended to a Work briefing — is keyed by **issue number**, not
+  milestone, and fires whenever the repo has an acceptance driver configured and
+  `ms_dir_for_issue` finds a slice for that issue. An `issue-NN/` slice is
+  discovered by the exact same call as an `ms-NN/` one. This is why "briefing-
+  contract auto-injection" is explicitly out of scope for this issue's deliverable
+  list below: it isn't missing, it's already generic. See
+  `TestBugLaneNeedsNoMilestone` in `tests/test_acceptance.py` for the end-to-end
+  proof (a hand-authored `issue-NN/manifest.yml`, no `ms-*` directory anywhere,
+  resolves through `load_manifest` → `ms_dir_for_issue` →
+  `oracle_loop_contract_block` unmodified).
+- **The four fields themselves already reach the Work briefing, verbatim, with no
+  bug-lane-specific code at all.** `coord assign`/`coord dispatch` (the headless
+  dispatch every auto-loop uses) auto-generates the briefing from the raw issue
+  body whenever no explicit `--briefing` is given
+  (`coord/commands/dispatch.py`: `briefing = f"Issue #{issue}: {issue_title}\n\n
+  {issue_body}"`) — this is completely generic, not something #1964 added. Because
+  `coord issue create --expected/--actual/--repro/--evidence` writes the four
+  fields into the issue body as literal `##` sections (Deliverable 1), they ride
+  along in that auto-generated briefing intact, underneath the oracle-contract
+  block pointing at `contract.md`. Nothing about "make the four fields reach the
+  briefing" needed building — it falls out of Deliverable 1 (structured sections,
+  not prose) plus machinery that already existed.
+
+**Authoring is hand-first.** Read the issue's four fields directly (no parsing
+needed — that's the point of shipping them as sections) and write `contract.md` by
+hand, scoped to the **one behaviour** the bug describes — not a whole surface, not
+a whole milestone. `JDonaghy/vimcode#622` already establishes this is workable by
+hand. An agent-assisted authoring dispatch (mirroring `coord acceptance mock`'s
+independent-agent shape, but keyed by issue number with no milestone lookup) is a
+natural follow-up once hand-authoring has enough mileage to know what to automate
+— not built by this issue. Explicitly out of scope here, same as the milestone
+ceremony above: Gate-A sign-off, stall-protocol automation beyond what already
+exists issue-number-keyed (`coord acceptance stall` already takes no milestone
+argument either).
+
 ## Known-good worked example
 
 The first pass through this loop should be the vimcode extensions-panel help popup,
@@ -168,12 +242,69 @@ found by operator smoke on 2026-08-07:
 
 - **Expected**: full box border, title centred in the top border.
 - **Actual**: side-bars only, title demoted to a content row.
+- **Reproduction**: open vimcode, focus the extensions panel, press `?`.
 - **Evidence**: screenshots of both, plus `develop` as a working reference.
 - **Root cause**: already filed upstream as quadraui#541.
 
 It is an ideal rehearsal because the expensive part — characterising the bug — is
 already done, and it exercises every stage of the lane including the upstream-vs-local
-fork.
+fork. Walked through end to end, in the shape #1964 ships:
+
+1. **Intake.**
+   ```
+   coord issue create vimcode \
+     --title "Extensions-panel help popup: missing top/bottom border" \
+     --expected "Full box border, title centred in the top border segment." \
+     --actual "Side-bars only (left/right verticals); title demoted to a plain content row." \
+     --repro "Open vimcode, focus the extensions panel, press ? to open the help popup." \
+     --evidence "Screenshots of both states, plus develop (pre-regression) as a working reference — quadraui#541 has the upstream root cause."
+   ```
+   This lands as vimcode issue #625, body already split into the four `##`
+   sections above — nothing left to re-derive.
+
+2. **Contract authoring (hand, scoped to the one behaviour).** Read #625 directly
+   and write `tests/acceptance/issue-625/contract.md` in vimcode's checkout:
+
+   ```markdown
+   # Bug-lane contract — issue #625: extensions-panel help popup border
+
+   ## The one behaviour
+   `TuiDriver` renders the help popup as a bordered box:
+   - Row 0 (top border) is a full horizontal rule using the top-left/top-right
+     corner glyphs at both ends — `driver.find(top_left)` and
+     `driver.find(top_right)` both return `Some(..)` on the popup's top row.
+   - The popup's title text is found on that same top row, horizontally
+     centred — not on a separate content row below the border.
+   - Left/right columns render the vertical border glyph on every popup row
+     (this part already worked pre-regression; asserting it too catches a
+     half-fix that adds a top rule but drops the sides).
+
+   ## Done condition (the red gate)
+   Before any fix, a test asserting the three bullets above must FAIL,
+   specifically on the title-row / top-border assertions. After the fix, the
+   same test — unmodified — goes green.
+   ```
+
+   Then a matching `tests/acceptance/issue-625/manifest.yml`
+   (`tests: {help_popup_border::has_top_and_bottom_rule: 625, ...}`) and the
+   actual `TuiDriver` assertions, committed to vimcode's `tests/acceptance/`
+   the same way any `ms-NN` slice is.
+
+3. **Red gate.** `coord acceptance run --repo vimcode --issue 625` must FAIL,
+   for the title/border reason above, before any fix lands — proves the test
+   exercises the reported bug rather than passing vacuously.
+
+4. **Dispatch, fix, converge.** The issue dispatches as ordinary `work` (no
+   milestone, no Gate A to wait on). The worker briefing already carries the
+   "🔒 Oracle-loop acceptance contract" block pointing at
+   `tests/acceptance/issue-625/contract.md`, and iterates with
+   `coord acceptance run --repo vimcode --issue 625` until green, same loop as
+   the feature lane.
+
+5. **Trust gate + cadence.** `coord acceptance record --repo vimcode --issue 625
+   --sha <pushed-sha>` re-runs the sealed slice externally. Because vimcode's real
+   test command runs the whole accumulated `tests/acceptance/` tree (#1950), this
+   slice re-runs on every later issue forever — coverage ratchets, it does not rot.
 
 ## What this program is *not*
 

{code_coordinator-0.5.48 → code_coordinator-0.5.49}/tests/test_acceptance.py

@@ -14,8 +14,10 @@ from coord.acceptance import (
     ManifestError,
     acceptance_capability_gap,
     build_verdict,
+    bug_contract_path,
     dump_manifest_error_hint,
     failure_summary,
+    issue_dirname,
     load_manifest,
     ms_dir_for_issue,
     oracle_loop_contract_block,
@@ -247,6 +249,45 @@ class TestOracleLoopContractBlock:
         assert "not the other way around" in block
 
 
+class TestIssueDirnameAndBugContractPath:
+    """#1964 (docs/TEST_FIRST_BUG_LANE.md): the bug lane's single-issue
+    counterpart to ms_dirname/gate_a_contract_path — no milestone number
+    anywhere in the name."""
+
+    def test_issue_dirname(self) -> None:
+        assert issue_dirname(1234) == "issue-1234"
+
+    def test_bug_contract_path(self) -> None:
+        assert bug_contract_path(1234) == "tests/acceptance/issue-1234/contract.md"
+
+
+class TestBugLaneNeedsNoMilestone:
+    """#1964: end-to-end proof that a hand-authored `issue-NN/` slice —
+    with no `ms-NN/` directory anywhere in the tree, and no milestone
+    involved at any step — is discovered, scoped, and injected into the
+    worker briefing by the exact same machinery an `ms-NN/` slice uses.
+    This is the acceptance bar for "no milestone ceremony required"."""
+
+    def test_manifest_and_contract_block_work_with_only_an_issue_dir(
+        self, tmp_path: Path
+    ) -> None:
+        root = tmp_path / "tests" / "acceptance"
+        bug_dir = root / issue_dirname(1234)
+        bug_dir.mkdir(parents=True)
+        (bug_dir / "manifest.yml").write_text("tests:\n  issue_1234::popup_border: 1234\n")
+
+        assert ms_dir_for_issue(root, 1234) == "issue-1234"
+        manifest = load_manifest(root)
+        assert manifest == {"issue_1234::popup_border": 1234}
+
+        block = oracle_loop_contract_block(root, "vimcode", 1234)
+        assert bug_contract_path(1234) in block
+        assert "coord acceptance run --repo vimcode --issue 1234" in block
+        # No ms-* dir exists anywhere — confirm the fixture itself proves the
+        # negative, not just that the assertions above happened to pass.
+        assert not list(root.glob("ms-*"))
+
+
 class TestAcceptanceCapabilityGap:
     """#966: cheap detection mirroring `coord.smoke.pick_smoke_machine`'s
     candidate filter — no remote-exec plumbing, just "is this the wrong

code_coordinator-0.5.49/tests/test_bug_intake.py

@@ -0,0 +1,93 @@
+"""Tests for coord/bug_intake.py — the bug-lane intake contract's four-field
+format/parse round-trip (#1964, docs/TEST_FIRST_BUG_LANE.md)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from coord.bug_intake import BugReport, FIELDS, format_bug_report, parse_bug_report
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+
+
+class TestFormatBugReport:
+    def test_renders_all_four_sections_in_order(self) -> None:
+        body = format_bug_report(
+            expected="full box border", actual="side-bars only",
+            repro="open the extensions panel help popup",
+            evidence="screenshots of both, plus develop as a reference",
+        )
+        assert body.index("## Expected behaviour") < body.index("## Actual behaviour")
+        assert body.index("## Actual behaviour") < body.index("## Reproduction")
+        assert body.index("## Reproduction") < body.index("## Evidence")
+        assert "full box border" in body
+        assert "side-bars only" in body
+        assert "open the extensions panel help popup" in body
+        assert "develop as a reference" in body
+
+    def test_strips_surrounding_whitespace_per_field(self) -> None:
+        body = format_bug_report(
+            expected="  a  \n", actual="b", repro="c", evidence="d",
+        )
+        assert "## Expected behaviour\n\na" in body
+
+
+class TestParseBugReport:
+    def test_round_trips_through_format(self) -> None:
+        body = format_bug_report(
+            expected="a", actual="b", repro="c", evidence="d",
+        )
+        report = parse_bug_report(body)
+        assert report == BugReport(expected="a", actual="b", repro="c", evidence="d")
+
+    def test_none_when_no_headings_present(self) -> None:
+        assert parse_bug_report("just some freeform text, no structure") is None
+
+    def test_none_when_a_section_is_missing(self) -> None:
+        body = "## Expected behaviour\n\na\n\n## Actual behaviour\n\nb\n"
+        assert parse_bug_report(body) is None
+
+    def test_none_when_a_section_is_empty(self) -> None:
+        body = (
+            "## Expected behaviour\n\na\n\n"
+            "## Actual behaviour\n\nb\n\n"
+            "## Reproduction\n\n\n\n"
+            "## Evidence\n\nd\n"
+        )
+        assert parse_bug_report(body) is None
+
+    def test_tolerant_of_heading_level_and_case(self) -> None:
+        body = (
+            "# expected BEHAVIOUR\na\n"
+            "### actual behaviour\nb\n"
+            "## reproduction\nc\n"
+            "###### evidence\nd\n"
+        )
+        assert parse_bug_report(body) == BugReport(
+            expected="a", actual="b", repro="c", evidence="d",
+        )
+
+    def test_tolerant_of_prose_before_and_after(self) -> None:
+        body = (
+            "Some intro context an operator added.\n\n"
+            "## Expected behaviour\n\na\n\n"
+            "## Actual behaviour\n\nb\n\n"
+            "## Reproduction\n\nc\n\n"
+            "## Evidence\n\nd\n\n"
+            "Some trailing note.\n"
+        )
+        report = parse_bug_report(body)
+        assert report.expected == "a"
+        assert report.evidence == "d\n\nSome trailing note."
+
+
+class TestIssueTemplateHeadingsMatchModule:
+    """The GitHub-native template (.github/ISSUE_TEMPLATE/bug_report.md)
+    must render exactly the same four headings as this module, or a
+    hand-filed issue silently fails to `parse_bug_report` even though it
+    looks identical to a `coord issue create --expected ...`-authored one."""
+
+    def test_template_headings_match_and_parse(self) -> None:
+        template = (REPO_ROOT / ".github/ISSUE_TEMPLATE/bug_report.md").read_text()
+        for _, heading in FIELDS:
+            assert f"## {heading}" in template, f"missing heading: {heading!r}"