codna 0.2.13__tar.gz → 0.2.14__tar.gz

{codna-0.2.13 → codna-0.2.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codna
-Version: 0.2.13
+Version: 0.2.14
 Summary: Local-first repo intelligence and agent fixing for Codna.
 Author: Thyn
 Maintainer: Thyn

{codna-0.2.13 → codna-0.2.14}/codna/__init__.py

@@ -5,4 +5,4 @@ This package is the `codna` CLI. Users never touch "algenta" directly — the en
 is an internal dependency reached over HTTP.
 """
 
-__version__ = "0.2.13"
+__version__ = "0.2.14"

{codna-0.2.13 → codna-0.2.14}/codna/agent-core/run-server.bundle.mjs

@@ -110643,7 +110643,7 @@ var init_bowser = __esm(() => {
 
 // agent-core/vendor/cline/node_modules/.bun/@aws-sdk+core@3.974.15/node_modules/@aws-sdk/core/dist-cjs/submodules/client/index.js
 var require_client2 = __commonJS((exports) => {
-  var __dirname = "/Users/angel/actions-runner-mac-4/_work/codna/codna/agent-core/vendor/cline/node_modules/.bun/@aws-sdk+core@3.974.15/node_modules/@aws-sdk/core/dist-cjs/submodules/client";
+  var __dirname = "/Users/angel/Developer/actions-runner/_work/codna/codna/agent-core/vendor/cline/node_modules/.bun/@aws-sdk+core@3.974.15/node_modules/@aws-sdk/core/dist-cjs/submodules/client";
   var retry2 = require_retry2();
   var protocols = require_protocols();
   var lambdaInvokeStore = require_invoke_store();

{codna-0.2.13 → codna-0.2.14}/codna/webhook.py

@@ -141,6 +141,73 @@ def _safe_ref(value: Any) -> str | None:
     return value if isinstance(value, str) and value and not value.startswith("-") else None
 
 
+# --- feedback-repo cross-repo dispatch (thyn-ai/feedback -> a product's own repo) -----------------
+# Env, not a constant: any company adopting this must be able to point it at their own public
+# intake repo and their own product repos without a code change.
+_FEEDBACK_REPO_ENV = "CODNA_FEEDBACK_REPO"
+_FEEDBACK_ROUTES_ENV = "CODNA_FEEDBACK_ROUTES"
+_PRODUCT_LABEL_RE = re.compile(r"^product:(\S+)$")
+
+
+def feedback_repo() -> str | None:
+    """The public intake repo (e.g. ``thyn-ai/feedback``), or None when unconfigured -- in which
+    case feedback-repo events are just ordinary unrecognized events (204), not an error."""
+    return os.environ.get(_FEEDBACK_REPO_ENV) or None
+
+
+def feedback_routes() -> dict[str, str]:
+    """``{"algenta": "thyn-ai/algenta", ...}`` from CODNA_FEEDBACK_ROUTES (a JSON object). Malformed
+    or absent config yields an empty map -- every report then reports itself unrouted rather than
+    raising, since a config typo must never take down the whole webhook."""
+    raw = os.environ.get(_FEEDBACK_ROUTES_ENV)
+    if not raw:
+        return {}
+    try:
+        data = json.loads(raw)
+    except ValueError:
+        return {}
+    if not isinstance(data, dict):
+        return {}
+    return {str(k): str(v) for k, v in data.items() if isinstance(v, str) and "/" in v}
+
+
+def _product_from_labels(labels: Any) -> str | None:
+    """The bare product name from a ``product:<name>`` label on the issue, if present. The first
+    match wins (an issue should carry exactly one such label)."""
+    if not isinstance(labels, list):
+        return None
+    for entry in labels:
+        name = entry.get("name") if isinstance(entry, dict) else None
+        m = _PRODUCT_LABEL_RE.match(name or "")
+        if m:
+            return m.group(1)
+    return None
+
+
+def _classify_feedback_repo_fix(payload: Mapping[str, Any], *, installation: int | None,
+                                fallback_repo: str) -> WebhookJob:
+    """A ``codna-fix`` label on the public feedback repo: route by the issue's own
+    ``product:<name>`` label to that product's real repo, or explain why it couldn't."""
+    issue = payload.get("issue") or {}
+    number = issue.get("number")
+    product = _product_from_labels(issue.get("labels"))
+    target = feedback_routes().get(product) if product else None
+    ctx: dict[str, Any] = {"feedback_repo": fallback_repo, "feedback_issue": number,
+                           "fp": f"feedback#{number}"}
+    if target:
+        ctx["product"] = product
+        return WebhookJob("fix", target, installation_id=installation, context=ctx,
+                          reason="feedback_routed_fix")
+    reason = (f"no route is configured for product `{product}`" if product
+             else "no `product:<name>` label was found on this report")
+    ctx["routing_error"] = reason
+    # repo_full_name = the FEEDBACK repo itself (there is no target) + issue_number set, so the
+    # existing generic issue-outcome reporting in process_job posts the explanation without any
+    # feedback-specific plumbing -- this case needs none.
+    return WebhookJob("fix", fallback_repo, installation_id=installation, issue_number=number,
+                      context=ctx, reason="feedback_unrouted")
+
+
 def classify_event(event: str, payload: Mapping[str, Any]) -> WebhookJob | None:
     """Map a GitHub ``(event, payload)`` to a Codna job, or ``None`` to ignore it.
 
@@ -206,6 +273,12 @@ def classify_event(event: str, payload: Mapping[str, Any]) -> WebhookJob | None:
     if event == "issues" and action == "labeled":
         label = (payload.get("label") or {}).get("name")
         number = (payload.get("issue") or {}).get("number")
+        fbrepo = feedback_repo()
+        if fbrepo and repo == fbrepo and label == FIX_LABEL and isinstance(number, int):
+            # A report on the public intake repo, approved by a maintainer's codna-fix label:
+            # route it by product to that product's own (often private) repo. Same installation
+            # covers both -- the App is org-wide -- so no separate auth is needed to reach either.
+            return _classify_feedback_repo_fix(payload, installation=installation, fallback_repo=fbrepo)
         if label == FIX_LABEL:
             return WebhookJob("fix", repo, installation_id=installation, issue_number=number, reason="labeled_codna_fix")
         if label == SECURE_LABEL:
@@ -342,7 +415,13 @@ def codna_command(
         return args
     if job.kind == "fix":
         ctx = job.context or {}
-        if ctx:
+        # `in_reply_to_id` is set ONLY by _fix_context_from_review_comment, which itself returns
+        # None when it's absent -- so it is a precise, structural discriminator for "this is a
+        # comment-fix", never a coincidental one. A feedback-routed job has context (product,
+        # feedback_repo, ...) but never this key, so it correctly falls through below instead of
+        # being force-fit into the comment-fix shape (which needs head_ref -- a PR branch that
+        # doesn't exist for an issue filed on a different repo entirely).
+        if ctx.get("in_reply_to_id"):
             # Comment-triggered verified fix of a specific review finding. Analyze the PR head (--ref)
             # and target the PR's OWN branch (--base-branch head_ref) so the fix stacks onto the PR.
             if not ctx.get("head_ref"):
@@ -359,10 +438,18 @@ def codna_command(
             # A fix job with a ref but no comment context and no issue text -- let codna discover
             # what's actually failing by running the repo's own tests against this commit.
             args += ["--ref", job.ref, "--tests"]
-        elif job.issue_number:
-            # Label-triggered (labeled_codna_fix): no commit/tests to run -- `codna fix` requires
-            # one of --issue/--tests/--from-junit or it dies immediately (fix_run.py), so the
-            # caller (run_codna_job) must have already fetched the issue body.
+        elif job.issue_number or issue_text or ctx.get("feedback_issue"):
+            # Label-triggered (labeled_codna_fix, or a feedback-routed report -- both have no
+            # commit/tests to run): `codna fix` requires one of --issue/--tests/--from-junit or it
+            # dies immediately (fix_run.py), so the caller (run_codna_job) must have already
+            # fetched the text -- from the issue itself, or (feedback-routed) from the public
+            # report, since job.issue_number is None there and there is nothing else to fetch.
+            #
+            # `ctx.get("feedback_issue")` alone (without job.issue_number or a passed issue_text)
+            # must STILL enter this branch: a feedback job with NO issue_text supplied is exactly
+            # the fetch-failure case, and skipping this branch entirely would silently build an
+            # incomplete `codna fix --open-pr` with no --issue/--tests, which `codna fix` itself
+            # would then reject at run time instead of failing here with a catchable error.
             if not issue_text:
                 raise WebhookError(
                     "fix_requires_issue_text",
@@ -386,6 +473,13 @@ def codna_command(
                 f"Automated fix opened by the Codna GitHub App for #{job.issue_number}.\n\n"
                 f"{webhook_marker(job)}"
             )
+        elif ctx.get("feedback_repo") and ctx.get("feedback_issue"):
+            # Cross-link to the PUBLIC report, not to job.issue_number (there is none -- the issue
+            # lives on the feedback repo, not this one).
+            body = (
+                f"Automated fix opened by the Codna GitHub App for a report filed at "
+                f"{ctx['feedback_repo']}#{ctx['feedback_issue']}.\n\n{webhook_marker(job)}"
+            )
         args += ["--pr-body", body]
         return args
     raise WebhookError("unknown_job_kind", f"unknown job kind {job.kind!r}")

{codna-0.2.13 → codna-0.2.14}/codna/webhook_worker.py

@@ -156,13 +156,30 @@ def run_codna_job(job: WebhookJob, *, token: str | None, engine_key: str | None,
                   provider: str | None = None, provider_key: str | None = None,
                   codna_bin: str = "codna") -> JobResult:
     """Default runner: run packaged codna for the job in an isolated, scrubbed workspace."""
+    ctx = job.context or {}
+    if job.kind == "fix" and ctx.get("routing_error"):
+        # A report on the feedback repo with no product route: this is a correctly-handled
+        # non-run, not a failure to retry (same convention as the "org not linked" / "automation
+        # disabled" branches in process_job) -- report=True carries the explanation through to the
+        # comment posted on the public issue, and spends nothing running codna for nowhere to go.
+        return JobResult(True, ctx["routing_error"])
     with tempfile.TemporaryDirectory(prefix="codna-webhook-job-") as tmp:
         if job.kind == "secure":
             if not token:
                 return JobResult(False, "secure job needs an installation token to fetch SARIF")
             sarif_path = webhook_github.fetch_code_scanning_sarif(job.repo_full_name, token, dest_dir=tmp)
             argv = codna_command(job, sarif_path=sarif_path)
-        elif job.kind == "fix" and job.issue_number and not (job.context or {}):
+        elif job.kind == "fix" and ctx.get("feedback_issue") and not ctx.get("in_reply_to_id"):
+            # Feedback-routed fix: the issue lives on the FEEDBACK repo, not job.repo_full_name (the
+            # routed TARGET repo this token is scoped to) -- so there is nothing this function can
+            # fetch itself. process_job mints a second, feedback-repo-scoped token and fetches the
+            # text into ctx["issue_text"] before calling this runner; a missing value here means
+            # that fetch failed, and must be reported, not silently swapped for the wrong text.
+            issue_text = ctx.get("issue_text")
+            if not issue_text:
+                return JobResult(False, "feedback-routed fix is missing its report text (fetch failed)")
+            argv = codna_command(job, issue_text=issue_text)
+        elif job.kind == "fix" and job.issue_number and not ctx:
             # Label-triggered fix (no ref, no comment context): `codna fix` needs the issue's own
             # text to know what to fix -- fetch it now, the one thing codna_command can't do itself
             # (it has no token). A fetch failure/empty issue must not silently no-op: report it the
@@ -292,6 +309,27 @@ def process_job(
             github.post_review_comment_reply(job.repo_full_name, token, job.pr_number, reply_to, skip)
             return JobResult(True, f"comment-fix not run: {skip[:120]}")
 
+    # Feedback-routed fix: job.repo_full_name is the ROUTED TARGET repo (that's what the token
+    # minted above is scoped to), but the report text lives on the FEEDBACK repo -- a different
+    # repo under the same installation. Mint a second, feedback-scoped token to read it. A mint or
+    # fetch failure here must not crash the job: run_codna_job's own guard (ctx["issue_text"]
+    # missing) turns it into a clean, reportable JobResult instead.
+    feedback_repo_name = ctx.get("feedback_repo")
+    feedback_issue = ctx.get("feedback_issue")
+    feedback_token: str | None = None
+    if (job.kind == "fix" and feedback_repo_name and feedback_issue and not ctx.get("routing_error")
+            and app_id and private_key and job.installation_id):
+        try:
+            feedback_token = github.installation_token(
+                app_id, private_key, job.installation_id, repo_full_name=feedback_repo_name, kind="fix",
+            )
+        except Exception:  # noqa: BLE001 — a mint failure degrades to a reported fetch failure, not a crash
+            feedback_token = None
+        if feedback_token:
+            issue_text = github.fetch_issue_text(feedback_repo_name, feedback_token, feedback_issue)
+            if issue_text:
+                ctx["issue_text"] = issue_text
+
     # Idempotency: reuse a PR a prior attempt already opened. Checked BEFORE the ack so a redelivery
     # doesn't post a spurious "analyzing…" then "already opened". For a comment-fix only an OPEN PR
     # counts as a live duplicate — a closed prior fix PR must not block re-requesting a fresh one.
@@ -340,13 +378,22 @@ def process_job(
     # opened a correct fix PR and the issue's newest comment was still an OLD failure, so the issue
     # looked broken while the work was done. Now the issue always gets the outcome, with a link.
     if not check_id and not reply_to and token and job.issue_number:
+        if ctx.get("routing_error"):
+            # An unrouted report on the feedback repo itself: job.repo_full_name IS the feedback
+            # repo here (there was no target to route to), so this posts correctly with the SAME
+            # token already minted above -- no feedback-specific plumbing needed for this branch.
+            github.post_issue_comment(
+                job.repo_full_name, token, job.issue_number,
+                f"⚠️ Codna couldn't route this report automatically: {ctx['routing_error']}. "
+                "Add the right `product:<name>` label and re-apply `codna-fix` to retry.",
+            )
         # `job.kind == "fix"` is required for the SUCCESS half: the `codna-secure` label produces an
         # issue-triggered job with no ref and no thread too, but it is a READ-ONLY classification pass
         # that never opens a PR (codna_command builds `codna secure` without --open-pr). Without this
         # term, a clean secure run posted "✅ ... opened a pull request for it." and sent the user
         # hunting for a PR that does not exist -- the same kind of false statement this whole change
         # exists to remove.
-        if result.ok and job.kind == "fix":
+        elif result.ok and job.kind == "fix":
             pr_url = None
             try:
                 pr_url = github.find_open_pr_by_marker(job.repo_full_name, token, webhook_marker(job))
@@ -368,6 +415,26 @@ def process_job(
                 job.repo_full_name, token, job.issue_number,
                 f"⚠️ Codna couldn't finish this fix: {result.summary}",
             )
+    # Feedback-routed fix that DID have a target: job.issue_number is None (there is no issue in the
+    # TARGET repo), so the generic per-issue block above never fires for it -- report back to the
+    # PUBLIC issue instead, using the feedback-scoped token (the job's own `token` is scoped only to
+    # the target repo and cannot post there).
+    if feedback_repo_name and feedback_issue and not ctx.get("routing_error"):
+        comment_token = feedback_token or token
+        if comment_token:
+            if result.ok:
+                pr_url = None
+                try:
+                    # The PR, if any, is in the TARGET repo -- look it up with the token scoped
+                    # there, never with the feedback-scoped token (which cannot see it).
+                    pr_url = github.find_open_pr_by_marker(job.repo_full_name, token, webhook_marker(job))
+                except Exception:  # noqa: BLE001 — never turn a successful fix into a failure over a lookup
+                    pr_url = None
+                msg = (f"✅ Codna opened a fix in {job.repo_full_name}: {pr_url}" if pr_url
+                       else f"✅ Codna finished this fix in {job.repo_full_name} and opened a pull request for it.")
+            else:
+                msg = f"⚠️ Codna couldn't finish this fix in {job.repo_full_name}: {result.summary}"
+            github.post_issue_comment(feedback_repo_name, comment_token, feedback_issue, msg)
     # Reply the outcome ONCE: on success immediately, on failure only when the job is out of retries
     # (else a transient-then-succeeding fix would leave a spurious fail-closed reply, and every failed
     # attempt would spam the thread).

{codna-0.2.13 → codna-0.2.14}/codna.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codna
-Version: 0.2.13
+Version: 0.2.14
 Summary: Local-first repo intelligence and agent fixing for Codna.
 Author: Thyn
 Maintainer: Thyn

{codna-0.2.13 → codna-0.2.14}/codna.egg-info/SOURCES.txt

@@ -182,10 +182,12 @@ tests/test_telys_runtime_packaging.py
 tests/test_testrun.py
 tests/test_verify_pypi_trusted_publisher.py
 tests/test_webhook.py
+tests/test_webhook_feedback_dispatch.py
 tests/test_webhook_github.py
 tests/test_webhook_metering.py
 tests/test_webhook_queue.py
 tests/test_webhook_worker.py
+tests/test_webhook_worker_feedback_dispatch.py
 tests/test_wheel_guard.py
 tests/test_wheel_smoke_script.py
 tests/test_worker.py

{codna-0.2.13 → codna-0.2.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codna"
-version = "0.2.13"
+version = "0.2.14"
 description = "Local-first repo intelligence and agent fixing for Codna."
 readme = "README.md"
 requires-python = ">=3.10"

codna-0.2.14/tests/test_webhook_feedback_dispatch.py

@@ -0,0 +1,158 @@
+"""Cross-repo dispatch: a `codna-fix` label on the public feedback repo routes by the issue's own
+`product:<name>` label to that product's real (often private) repo.
+
+Pure-core tests only (classify_event / codna_command) — no network, matching test_webhook.py's
+conventions. process_job/run_codna_job's two-token-mint + outcome-comment behavior is covered
+separately in test_webhook_worker_feedback_dispatch.py, since that needs the fake GitHub client.
+"""
+from __future__ import annotations
+
+import pytest
+
+from codna.webhook import FIX_LABEL, WebhookError, WebhookJob, classify_event, codna_command, webhook_marker
+
+
+def _feedback_env(monkeypatch, routes: dict[str, str] | None = None) -> None:
+    monkeypatch.setenv("CODNA_FEEDBACK_REPO", "thyn-ai/feedback")
+    import json
+
+    monkeypatch.setenv("CODNA_FEEDBACK_ROUTES", json.dumps(routes if routes is not None else {
+        "algenta": "thyn-ai/algenta", "codna": "thyn-ai/codna",
+    }))
+
+
+def _labeled_payload(*, number: int, product_labels: list[str], installation: int = 7) -> dict:
+    return {
+        "action": "labeled",
+        "repository": {"full_name": "thyn-ai/feedback"},
+        "installation": {"id": installation},
+        "label": {"name": FIX_LABEL},
+        "issue": {"number": number, "labels": [{"name": n} for n in product_labels]},
+    }
+
+
+# ── routing: the successful case ────────────────────────────────────────────────────────────────
+def test_routes_to_the_target_repo_named_by_the_product_label(monkeypatch):
+    _feedback_env(monkeypatch)
+    job = classify_event("issues", _labeled_payload(number=42, product_labels=["needs-triage", "product:codna"]))
+
+    assert job.kind == "fix"
+    assert job.repo_full_name == "thyn-ai/codna"     # the ROUTED target, not the feedback repo
+    assert job.installation_id == 7
+    assert job.issue_number is None                  # no issue in the target repo -- context carries it
+    assert job.context["feedback_repo"] == "thyn-ai/feedback"
+    assert job.context["feedback_issue"] == 42
+    assert job.context["product"] == "codna"
+    assert "routing_error" not in job.context
+    assert job.reason == "feedback_routed_fix"
+
+
+def test_the_marker_is_unique_per_feedback_issue():
+    """REGRESSION-shaped: a ref-less, issue-number-less job would otherwise collapse to the literal
+    marker "default" (webhook_marker's fallback), and a second unrelated feedback report would be
+    silently treated as "already opened (idempotent reuse)" of the FIRST one's PR."""
+    j1 = WebhookJob("fix", "thyn-ai/codna", context={"feedback_repo": "thyn-ai/feedback",
+                                                     "feedback_issue": 1, "fp": "feedback#1"})
+    j2 = WebhookJob("fix", "thyn-ai/codna", context={"feedback_repo": "thyn-ai/feedback",
+                                                     "feedback_issue": 2, "fp": "feedback#2"})
+    assert webhook_marker(j1) != webhook_marker(j2)
+    assert "feedback#1" in webhook_marker(j1)
+    assert "feedback#2" in webhook_marker(j2)
+
+
+# ── routing: the unrouted / negative cases ──────────────────────────────────────────────────────
+def test_unrouted_when_no_product_label_is_present(monkeypatch):
+    _feedback_env(monkeypatch)
+    job = classify_event("issues", _labeled_payload(number=9, product_labels=["needs-triage"]))
+
+    assert job.repo_full_name == "thyn-ai/feedback"   # stays on the feedback repo -- there's no target
+    assert job.issue_number == 9                      # so the generic issue-comment path can report it
+    assert "no `product:<name>` label" in job.context["routing_error"]
+    assert job.reason == "feedback_unrouted"
+
+
+def test_unrouted_when_the_products_route_is_not_configured(monkeypatch):
+    _feedback_env(monkeypatch, routes={"algenta": "thyn-ai/algenta"})  # no "sqai" entry
+    job = classify_event("issues", _labeled_payload(number=9, product_labels=["product:sqai"]))
+
+    assert job.repo_full_name == "thyn-ai/feedback"
+    assert "no route is configured for product `sqai`" in job.context["routing_error"]
+
+
+def test_a_malformed_routes_env_degrades_to_unrouted_not_a_crash(monkeypatch):
+    monkeypatch.setenv("CODNA_FEEDBACK_REPO", "thyn-ai/feedback")
+    monkeypatch.setenv("CODNA_FEEDBACK_ROUTES", "{not valid json")
+    job = classify_event("issues", _labeled_payload(number=1, product_labels=["product:codna"]))
+    assert job.context["routing_error"]
+
+
+def test_feedback_dispatch_is_off_when_codna_feedback_repo_is_unset(monkeypatch):
+    """No CODNA_FEEDBACK_REPO configured -> this is just an ordinary codna-fix label on whatever
+    repo it was applied to, exactly as it worked before this feature existed."""
+    monkeypatch.delenv("CODNA_FEEDBACK_REPO", raising=False)
+    payload = _labeled_payload(number=9, product_labels=["product:codna"])
+    payload["repository"]["full_name"] = "thyn-ai/feedback"  # even ON what WOULD be the feedback repo
+    job = classify_event("issues", payload)
+    assert job.reason == "labeled_codna_fix"          # ordinary label path, not feedback dispatch
+    assert job.context is None
+
+
+def test_a_report_on_a_DIFFERENT_repo_never_triggers_feedback_dispatch(monkeypatch):
+    """CODNA_FEEDBACK_REPO is configured, but this label event is on some OTHER repo -- must take
+    the ordinary label path, not be mistaken for a feedback report just because routing is on."""
+    _feedback_env(monkeypatch)
+    payload = _labeled_payload(number=9, product_labels=["product:codna"])
+    payload["repository"]["full_name"] = "acme/unrelated-repo"
+    job = classify_event("issues", payload)
+    assert job.repo_full_name == "acme/unrelated-repo"
+    assert job.reason == "labeled_codna_fix"
+    assert job.context is None
+
+
+# ── codna_command: the discriminator between comment-fix and feedback-routed shapes ─────────────
+def test_feedback_routed_job_uses_the_plain_issue_shape_not_comment_fix():
+    """REGRESSION-shaped: `if ctx:` alone would force-fit a feedback-context job into the
+    comment-fix branch (which requires head_ref -- a PR branch that doesn't exist here) and raise
+    fix_requires_head_ref instead of building a normal --issue command."""
+    job = WebhookJob("fix", "thyn-ai/codna",
+                     context={"feedback_repo": "thyn-ai/feedback", "feedback_issue": 5, "fp": "feedback#5"})
+    cmd = codna_command(job, issue_text="codna report: something is broken")
+    assert cmd[:4] == ["codna", "fix", "https://github.com/thyn-ai/codna.git", "--open-pr"]
+    assert cmd[cmd.index("--issue") + 1] == "codna report: something is broken"
+    assert "--base-branch" not in cmd and "--ref" not in cmd
+
+
+def test_feedback_routed_job_without_issue_text_raises_a_catchable_error():
+    job = WebhookJob("fix", "thyn-ai/codna",
+                     context={"feedback_repo": "thyn-ai/feedback", "feedback_issue": 5, "fp": "feedback#5"})
+    with pytest.raises(WebhookError) as exc:
+        codna_command(job)  # no issue_text supplied
+    assert exc.value.code == "fix_requires_issue_text"
+
+
+def test_feedback_routed_pr_body_cross_links_the_public_issue_not_a_local_one():
+    job = WebhookJob("fix", "thyn-ai/codna",
+                     context={"feedback_repo": "thyn-ai/feedback", "feedback_issue": 5, "fp": "feedback#5"})
+    cmd = codna_command(job, issue_text="x")
+    body = cmd[cmd.index("--pr-body") + 1]
+    assert "thyn-ai/feedback#5" in body
+    assert webhook_marker(job) in body
+
+
+def test_comment_fix_shape_is_unaffected_by_the_new_discriminator():
+    """The existing comment-fix path (identified by in_reply_to_id) must still work exactly as
+    before -- the feedback-routing addition must not have narrowed what counts as a comment-fix."""
+    ctx = {"in_reply_to_id": 111, "head_sha": "deadbeef", "head_ref": "feature", "title": "SQL injection"}
+    job = WebhookJob("fix", "acme/app", ref="deadbeef", pr_number=7, context=ctx)
+    cmd = codna_command(job)
+    assert cmd[:3] == ["codna", "fix", "https://github.com/acme/app.git"]
+    assert "--base-branch" in cmd and cmd[cmd.index("--base-branch") + 1] == "feature"
+
+
+def test_comment_fix_without_head_ref_still_raises_fix_requires_head_ref():
+    """REGRESSION-shaped: confirms the new `ctx.get("in_reply_to_id")` discriminator still reaches
+    the head_ref check for a genuine (if malformed) comment-fix context."""
+    job = WebhookJob("fix", "acme/app", context={"in_reply_to_id": 111})  # no head_ref
+    with pytest.raises(WebhookError) as exc:
+        codna_command(job)
+    assert exc.value.code == "fix_requires_head_ref"