codna 0.2.13__tar.gz → 0.2.15__tar.gz

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

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

{codna-0.2.13 → codna-0.2.15}/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.15"

{codna-0.2.13 → codna-0.2.15}/codna/agent_core_runtime.py

@@ -421,12 +421,21 @@ def _stop_owned_sidecar(
         return
     if _request_owned_sidecar_shutdown(config):
         return
-    attempted_pids = [
-        pid
-        for pid in (listener.parent_pid, listener.pid)
-        if pid is not None
-    ]
-    attempted_pids = list(dict.fromkeys(attempted_pids))
+    # ONLY the verified listener PID -- never listener.parent_pid. `spawn_detached_process` execs
+    # the sidecar command directly (no wrapper process), so while the ORIGINAL caller that started
+    # it is still alive, lsof's reported "parent" IS that caller, not an orphaned launcher to clean
+    # up. On a single machine running several `codna fix` invocations at once (concurrent webhook
+    # jobs, or just two terminals), that caller is frequently a DIFFERENT process doing DIFFERENT,
+    # unrelated, still-useful work — and this used to SIGTERM-then-SIGKILL it, not just the
+    # sidecar. Confirmed live: two concurrent fixes with different provider keys triggered
+    # state_fingerprint_or_provider_mismatch, and the "cleanup" killed the peer's own `codna fix`
+    # process before its sidecar. `listener.pid` is independently verified as the thing actually
+    # LISTENING on the port (that's what put it in `listener` at all); nothing here is verified
+    # about parent_pid beyond "lsof reported some number as PPID at one instant." A leftover
+    # parent that genuinely has nothing left to do exits on its own once its child (the sidecar)
+    # is gone; a manual `codna doctor` hint can still suggest killing it explicitly (see
+    # _manual_stop_command) — that's a human decision, never an automated one.
+    attempted_pids = [listener.pid]
     try:
         for pid in attempted_pids:
             terminate_pid(

{codna-0.2.13 → codna-0.2.15}/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.15}/codna/webhook_worker.py

@@ -21,6 +21,7 @@ fakes and no network.
 from __future__ import annotations
 
 import os
+import socket
 import subprocess
 import tempfile
 import threading
@@ -28,6 +29,7 @@ import time
 import sys
 import json
 from dataclasses import dataclass
+from pathlib import Path
 from typing import Any, Callable
 
 from . import webhook_github, webhook_metering
@@ -129,15 +131,64 @@ def _comment_fix_result_msg(job: WebhookJob, token: str, result: "JobResult", gi
             "test + risk gate, so nothing was pushed (fail-closed). You can apply the fix manually.")
 
 
+def _free_port_pair() -> tuple[int, int] | None:
+    """Two ADJACENT free ports (engine, engine+1 for the sidecar -- runtime_config.
+    local_runtime_urls' own contract) via OS-assigned ephemeral ports, not a hash of job
+    identity: a hash risks two DIFFERENT jobs deriving the SAME port by coincidence, which is
+    exactly the collision this exists to eliminate, not reintroduce more quietly. Binding port 0
+    and reading back what the kernel assigned, then releasing it immediately, is the standard way
+    to get a free port without a race against every other consumer of "free port" on the box --
+    it isn't airtight (something else could grab it in the gap before the sidecar itself binds),
+    but that residual is the same one every ephemeral-port scheme accepts, not a new one.
+    Returns None (never raises) if binding just doesn't work; the caller falls back to sharing
+    the default ports rather than failing the job over a nice-to-have."""
+    for _attempt in range(5):
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as probe:
+                probe.bind(("127.0.0.1", 0))
+                base = probe.getsockname()[1]
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as probe:
+                probe.bind(("127.0.0.1", base + 1))
+        except OSError:
+            continue  # base+1 was taken; try another base rather than fail the job over this
+        return base, base + 1
+    return None
+
+
+def _isolated_runtime_env(tmp: str) -> dict[str, str]:
+    """CODNA_RUNTIME_ROOT + CODNA_PORT_BASE unique to THIS job, so concurrent jobs never share a
+    sidecar in the first place -- the root cause of the P0 this closes: two jobs sharing one
+    sidecar by design (same runtime_config_hash) tore each other's down mid-turn whenever their
+    provider keys differed, which is the routine case on a multi-tenant webhook, not an edge case.
+    CODNA_RUNTIME_ROOT nests inside the job's own scratch dir (`tmp`, already a fresh
+    TemporaryDirectory per job), so it's already guaranteed unique and is cleaned up for free when
+    that directory is removed -- no separate bookkeeping, nothing to leak across jobs.
+    """
+    env = {"CODNA_RUNTIME_ROOT": str(Path(tmp) / ".codna-runtime")}
+    ports = _free_port_pair()
+    if ports is not None:
+        env["CODNA_PORT_BASE"] = str(ports[0])
+    # No free-port fallback: CODNA_RUNTIME_ROOT alone still isolates each job's runtime STATE
+    # (they no longer read/write the same local-stack.json), even if two jobs end up sharing the
+    # default ports on a probe failure -- degraded, not broken, and never worth failing the job.
+    return env
+
+
 def _job_env(
     token: str | None, engine_key: str | None,
     provider: str | None = None, provider_key: str | None = None,
+    *, tmp: str | None = None,
 ) -> dict[str, str]:
     """Minimal allowlisted env + the scoped GitHub token, per-org Codna key, and (when the
     linked org has configured one) their own BYOK provider key — set consistently regardless of
     which of Anthropic/OpenAI/Google the org picked, so the local agent-core sidecar always finds
     a usable key instead of only ever checking for Anthropic's."""
     env = {k: v for k, v in os.environ.items() if k in _ENV_ALLOWLIST}
+    if tmp is not None:
+        # Job-specific isolation OVERRIDES whatever the host process's own env carries for these
+        # two keys -- inheriting the host's shared values here would silently defeat the whole
+        # point (every job would still resolve to the one shared runtime this exists to avoid).
+        env.update(_isolated_runtime_env(tmp))
     if token:
         env["GITHUB_TOKEN"] = token
     if engine_key:
@@ -156,13 +207,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
@@ -178,7 +246,7 @@ def run_codna_job(job: WebhookJob, *, token: str | None, engine_key: str | None,
         argv[0] = codna_bin
         try:
             proc = subprocess.run(
-                argv, env=_job_env(token, engine_key, provider, provider_key), cwd=tmp,
+                argv, env=_job_env(token, engine_key, provider, provider_key, tmp=tmp), cwd=tmp,
                 capture_output=True, text=True, timeout=_JOB_TIMEOUT_S,
                 start_new_session=True,  # own process group: isolated from signals, terminable as a unit
             )
@@ -292,6 +360,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 +429,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 +466,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.15}/codna.egg-info/PKG-INFO

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

{codna-0.2.13 → codna-0.2.15}/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.15}/pyproject.toml

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

{codna-0.2.13 → codna-0.2.15}/tests/test_agent_core_runtime.py

@@ -264,7 +264,10 @@ def test_agent_core_restarts_owned_runtime_when_fingerprint_is_stale(tmp_path, m
 
     assert endpoint.runtime_id == "runtime-2"
     assert endpoint.pid == 456
-    assert terminated == [456, 123]
+    # ONLY the verified listener (123) is auto-killed -- never the reported parent_pid (456), which
+    # on a machine running several codna invocations at once could be a live, unrelated process
+    # (see test_stop_owned_sidecar_never_auto_kills_the_reported_parent_pid for the direct case).
+    assert terminated == [123]
     assert starts == [True]
 
 
@@ -508,6 +511,57 @@ def test_agent_core_inspection_reports_stale_recovery_for_missing_state(
     }
 
 
+def test_provider_mismatch_never_kills_the_reported_parent_pid(tmp_path, monkeypatch) -> None:
+    """The actual P0: two concurrent `codna fix` processes share a sidecar by design (same
+    runtime_config_hash), and org B's own BYOK provider key differs from org A's -- a completely
+    routine, EXPECTED situation on a shared webhook worker, not a corruption. That must tear down
+    the sidecar (123) to restart it with B's env, but must NEVER touch parent_pid (456) -- on a
+    machine running concurrent fixes, "456" is frequently org A's own still-running `codna fix`
+    process, not an orphaned launcher. Reproduced directly against ensure_agent_core_running with
+    no mocked shortcuts around _stop_owned_sidecar itself.
+    """
+    monkeypatch.setenv("CODNA_RUNTIME_ROOT", str(tmp_path / ".codna"))
+    config = resolve_runtime_config()
+    state = {
+        "runtime_id": "runtime-org-a",
+        "codna_cli_version": config.codna_cli_version,
+        "sidecar_build_id": config.sidecar_build_id,
+        "runtime_config_hash": config.runtime_config_hash,
+        # Deliberately NO provider_env_hash -- org A's fix set this from ITS OWN provider key, and
+        # the absence here (rather than a matching one) is what drives both
+        # _state_provider_env_matches AND the legacy-hash fallback to False, landing on the exact
+        # branch that calls _stop_owned_sidecar(reason="state_fingerprint_or_provider_mismatch").
+    }
+    terminated: list[int] = []
+
+    monkeypatch.setattr(agent_core_runtime, "runtime_lock", _unlocked)
+    # 456 stands in for org A's OWN live `codna fix` process -- the one that spawned this sidecar
+    # and is still running it, exactly as `lsof -R` reports on a real machine while that process
+    # (start_new_session=True) hasn't exited yet.
+    monkeypatch.setattr(agent_core_runtime, "_single_listener", lambda port: _listener(port, parent_pid=456))
+    monkeypatch.setattr(agent_core_runtime, "_load_state", lambda _config: state)
+    monkeypatch.setattr(agent_core_runtime, "_state_owns_listener", lambda _state, _listener: True)
+    monkeypatch.setattr(agent_core_runtime, "_state_provider_env_matches", lambda _state, _keys: False)
+    monkeypatch.setattr(
+        agent_core_runtime,
+        "_service_is_codna_sidecar",
+        lambda active_config: _healthy_probe("runtime-org-a", build_id=active_config.sidecar_build_id),
+    )
+    monkeypatch.setattr(agent_core_runtime, "terminate_pid", lambda pid, **_kwargs: terminated.append(pid))
+    monkeypatch.setattr(agent_core_runtime, "_request_owned_sidecar_shutdown", lambda _config: False)
+    monkeypatch.setattr(
+        agent_core_runtime, "_start_sidecar",
+        lambda *_a, **_k: AgentCoreEndpoint(url="http://127.0.0.1:28601", port=28601,
+                                            runtime_id="runtime-org-b", pid=789),
+    )
+
+    endpoint = ensure_agent_core_running()
+
+    assert endpoint.runtime_id == "runtime-org-b"      # org B correctly got its own fresh sidecar
+    assert terminated == [123]                          # ONLY the verified sidecar listener
+    assert 456 not in terminated, "org A's own live process must never be auto-killed"
+
+
 def test_agent_core_stop_health_proven_stale_sidecar_stops_parent_then_child(
     tmp_path,
     monkeypatch,
@@ -538,7 +592,9 @@ def test_agent_core_stop_health_proven_stale_sidecar_stops_parent_then_child(
     assert payload["status"] == "stopped"
     assert payload["listener"]["pid"] == 123
     assert payload["listener"]["parent_pid"] == 456
-    assert stopped == [456, 123]
+    # parent_pid (456) is reported in the payload for diagnostics, but never auto-killed -- only
+    # the verified listener (123) is.
+    assert stopped == [123]
 
 
 def test_agent_core_stop_falls_back_without_runtime_lock_for_health_proven_sidecar(
@@ -579,7 +635,7 @@ def test_agent_core_stop_falls_back_without_runtime_lock_for_health_proven_sidec
     assert payload["lock_acquired"] is False
     assert payload["listener"]["pid"] == 123
     assert payload["listener"]["parent_pid"] == 456
-    assert stopped == [456, 123]
+    assert stopped == [123]