ctrlrelay 0.4.1__tar.gz → 0.7.0__tar.gz

{ctrlrelay-0.4.1 → ctrlrelay-0.7.0}/.github/workflows/build.yml

@@ -18,7 +18,7 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v7
 
       - name: Install uv
         uses: astral-sh/setup-uv@v7

{ctrlrelay-0.4.1 → ctrlrelay-0.7.0}/.github/workflows/pages.yml

@@ -25,7 +25,7 @@ jobs:
         working-directory: docs
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v7
 
       - name: Setup Ruby
         uses: ruby/setup-ruby@v1

{ctrlrelay-0.4.1 → ctrlrelay-0.7.0}/.github/workflows/publish.yml

@@ -29,7 +29,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v7
 
       - name: Install uv
         uses: astral-sh/setup-uv@v7

{ctrlrelay-0.4.1 → ctrlrelay-0.7.0}/.github/workflows/test.yml

@@ -15,7 +15,7 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v7
 
       - name: Install uv
         uses: astral-sh/setup-uv@v7

{ctrlrelay-0.4.1 → ctrlrelay-0.7.0}/CHANGELOG.md

@@ -7,6 +7,165 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.7.0] - 2026-09-04
+
+### Added
+
+- **`require_labels`: an AND-gate between assignment and a label,
+  closing the gap `include_labels` (#80) couldn't cover.** `exclude_labels`
+  is a block-list and `include_labels` is an OR-alternate trigger, but
+  neither could express "only pick this up if it's assigned to me AND
+  carries a specific label." On a repo with a long history of
+  self-assigned issues used as personal reminders, that meant the poller
+  replayed the whole backlog as new work the first time it saw the repo —
+  including issues that weren't code tasks at all. `require_labels`
+  (default `[]`, no behavior change) tightens the plain-assignment path
+  only: when set, an issue needs both the assignment and a matching label.
+  `include_labels` keeps triggering on a label match alone regardless.
+  An assigned issue missing the required label is left unmarked so a
+  later label addition still surfaces it. See #139.
+
+### Fixed
+
+- **`ctrlrelay setup --install-daemons` on a fresh SSH-only machine:
+  personalization clone ignored the configured git protocol, and
+  generated daemon units crash-looped.** The personalization repo
+  clone (setup pre-scan and `PersonalizationManager.init`) hardcoded
+  an HTTPS URL regardless of `gh`'s configured `git_protocol`,
+  so SSH-only operators hit `could not read Username` with the
+  failure buried in a single warning line while setup still exited
+  0. `ctrlrelay.gh_protocol` now reads `gh`'s configured protocol and
+  builds the matching clone URL; a personalization failure flips
+  `SetupResult.personalization_failed` so the CLI prints an ACTION
+  NEEDED banner and exits non-zero instead of silently continuing.
+  Separately, generated launchd/systemd units point
+  `StandardOutput`/`StandardError` at `~/.ctrlrelay/logs/`, which
+  setup never created — systemd refuses to start a unit with a
+  missing log dir (`EXIT_STDOUT`, 209), and with `Restart=always`
+  that's an immediate crash-loop. `write_units` now creates the log
+  dir up front and chmods unit files `0600` since they embed
+  `CTRLRELAY_TELEGRAM_TOKEN` in plaintext. See #137.
+
+## [0.6.0] - 2026-06-10
+
+### Added
+
+- **Secops sweeps now remember operator decisions across days.** The
+  `automation_decisions` table had a schema but no producer or consumer
+  — every 6am sweep re-asked about the same Dependabot PRs the operator
+  had already answered, drowning Telegram. Wired both halves:
+  1. When the BLOCKED loop in `run_secops_all` (or the out-of-band
+     `resume_secops_from_pending` sweeper) receives an answer, regex
+     extracts every PR# from the question and records one row per PR#
+     keyed on `(repo, "dependabot_pr", "#N")` with the operator's
+     verbatim answer. PR# regex handles both `PR #60` and bare `#60`
+     forms, dedupes, and tolerates questions with no PR# (e.g.
+     CodeQL-only) by writing nothing.
+  2. Before building each sweep's prompt, `run_secops_all` pulls the
+     last 30 days of decisions for that repo (namespaced to
+     `operation="dependabot_pr"` so e.g. CodeQL-suppression decisions
+     don't leak into the Dependabot prompt) and threads them via
+     `ctx.extra['prior_decisions']` into `_build_prompt`, which renders
+     a `## Prior operator decisions (last 30 days)` block listing each
+     decision verbatim alongside the original question snippet so the
+     agent can detect a force-pushed PR that swapped the version bump
+     under the same PR number. The block carries instructions to act
+     on prior answers unless circumstances have materially changed
+     (different version bump, CI state flipped). Without this the
+     persistence layer was dead weight.
+
+### Fixed
+
+- **Secops handles "no CI configured" without inventing options.**
+  Repos with no `.github/workflows/*` previously confused the agent
+  into freelance suggestions ("Want me to batch into a review PR?")
+  because the "auto-merge with passing CI" gate couldn't fire. Prompt
+  now explicitly directs: treat ALL Dependabot PRs as ASK regardless
+  of tier, and signal BLOCKED ONCE with a single consolidated question
+  per repo (not one per PR).
+- **Secops escalates pre-existing CI failures instead of stalling PRs.**
+  When CI is failing on a check unrelated to the PR's package (e.g.
+  `pip-audit` flagging a transitive CVE in `idna` while the PR bumps
+  `boto3`), patch PRs were sitting stuck for weeks because the agent
+  reported the failure and moved on. Prompt now requires the agent to
+  signal BLOCKED with a one-line question naming the underlying issue
+  and a root-cause hint from `gh run view --log-failed`.
+- **Secops scope discipline.** The prompt now enforces "exactly three
+  legitimate exits" per open PR (merge / leave / BLOCKED) and
+  explicitly forbids batching PRs into review PRs, opening tracking
+  issues, or performing manual reviews. Cuts off the freelance
+  options observed in production sweeps.
+
+## [0.5.0] - 2026-05-11
+
+Minor release. Three changes on the secops path; together they take the
+secops sweep from "silently drops operator decisions" to "respects per-repo
+policy and reaches the operator on every blocked decision".
+
+### Fixed
+
+- **Secops BLOCKED questions now reach the operator via Telegram.**
+  Three discrete bugs were stacking to drop every blocked secops session
+  silently (#131):
+  1. `run_secops_all` never called `transport.ask()` after a blocked
+     pipeline result. The DB row was marked `status='blocked'` and a
+     `pending_resumes` entry was inserted, but the question went nowhere.
+     Now mirrors the dev/task pipelines: post the question, await an
+     answer, resume — up to `DEFAULT_MAX_BLOCKED_ROUNDS=5` rounds. On
+     transport failure preserves `blocked=True` so the existing
+     persistence-on-blocked branch fires.
+  2. `ctrlrelay run secops` (manual CLI) was passing `transport=None`,
+     so even with the dispatch loop in place, the `is not None` gate
+     short-circuited and questions still went to pending_resumes
+     instead of Telegram. Now builds a `SocketTransport` when the
+     bridge socket is up, mirroring the scheduled-cron path.
+  3. `SocketTransport._receive_loop` resolved the per-request future on
+     the FIRST message matching `request_id`. The bridge sends two
+     messages for an ASK: an intermediate `ACK(status="pending")` then
+     a terminal `ANSWER`. Receiving the ACK fulfilled the future early
+     and `ask()` raised `TransportError("Unexpected response: BridgeOp.ACK")`.
+     Now skips `ACK(status="pending")` and waits for `ANSWER`/`ERROR`.
+
+  Real-world impact: an 86-repo secops sweep with 21 sessions hitting
+  BLOCKED produced zero Telegram messages pre-fix. Post-fix, every
+  blocked session reaches the operator with a structured question.
+
+### Added
+
+- **Auto-merge operator-authored `.github/dependabot.yml`-only PRs.**
+  The secops agent's policy treated all operator-authored PRs as needing
+  explicit approval, even ones that ONLY add an ecosystem entry to
+  `.github/dependabot.yml`. These are the prerequisite PRs the operator
+  files when bulk-enabling Dependabot across repos with branch protection,
+  and they sat indefinitely (#132). The carve-out is narrow and
+  multi-gated:
+  1. **Author check**: `author.login == $OPERATOR` (derived from
+     `gh api user --jq .login`) — collaborators, GitHub apps, or
+     external contributors are NOT eligible even for dependabot.yml-only.
+  2. **Diff check**: `gh pr diff` must be PURELY ADDITIVE — any line
+     beginning with `-` (other than `---` file headers) signals a
+     deletion or modification of existing config -> BLOCKED.
+  3. **CI check**: `gh pr checks` must all pass — a PR adding invalid
+     YAML can pass author+diff and still break Dependabot for the repo
+     if merged without this gate.
+
+  All three must pass before merge. Any one failing -> BLOCKED.
+
+- **Per-repo `automation:` policy now drives the secops agent.**
+  `orchestrator.yaml`'s per-repo `automation` block (defining
+  `dependabot_patch`, `dependabot_minor`, `dependabot_major` as
+  auto/ask/never) was decorative — the secops prompt had hardcoded
+  prose that ignored it (#133). Now `_build_prompt` accepts an
+  `AutomationConfig` and renders per-tier directives like
+  "patch updates: AUTO-MERGE", "minor updates: ASK", "major updates: NEVER"
+  per repo. `run_secops_all` puts `repo_config.automation` in
+  `ctx.extra`; `resume_secops_from_pending` accepts an `automation`
+  kwarg; the pending-resume sweeper in `cli.py` looks up the per-repo
+  policy and threads it on resume.
+
+  Operators can now set a sensitive repo to `dependabot_minor: never`
+  and the agent will actually respect it.
+
 ## [0.4.1] - 2026-05-08
 
 Patch release. Two follow-ups against the v0.4.0 setup flow surfaced
@@ -1073,7 +1232,9 @@ pipeline).
   per-phase implementation plans (Phase 0 through Phase 4).
 - `docs/Claude_Code_Project_Guide.md` — project development guide.
 
-[Unreleased]: https://github.com/AInvirion/ctrlrelay/compare/v0.1.3...HEAD
+[Unreleased]: https://github.com/AInvirion/ctrlrelay/compare/v0.7.0...HEAD
+[0.7.0]: https://github.com/AInvirion/ctrlrelay/compare/v0.6.0...v0.7.0
+[0.6.0]: https://github.com/AInvirion/ctrlrelay/compare/v0.5.0...v0.6.0
 [0.1.3]: https://github.com/AInvirion/ctrlrelay/releases/tag/v0.1.3
 [0.1.1]: https://github.com/AInvirion/ctrlrelay/releases/tag/v0.1.1
 [0.1.0]: https://github.com/AInvirion/ctrlrelay/releases/tag/v0.1.0

{ctrlrelay-0.4.1 → ctrlrelay-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: ctrlrelay
-Version: 0.4.1
+Version: 0.7.0
 Summary: Local-first orchestrator for headless coding agents across multiple GitHub repos
 Project-URL: Homepage, https://github.com/AInvirion/ctrlrelay
 Project-URL: Documentation, https://ainvirion.github.io/ctrlrelay/

{ctrlrelay-0.4.1 → ctrlrelay-0.7.0}/config/orchestrator.yaml.example

@@ -139,3 +139,10 @@ repos: []
   #     # Matching is case-insensitive. Defaults to ["manual", "operator",
   #     # "instruction"]; override with an empty list to disable.
   #     exclude_labels: ["manual", "operator", "instruction"]
+  #     # Gates the plain-assignment trigger: when set, assignment alone
+  #     # is no longer enough on its own — an issue must ALSO carry at
+  #     # least one of these labels to be picked up. Does not affect
+  #     # include_labels, which still triggers on a label match alone.
+  #     # Matching is case-insensitive. Defaults to [] (assignment alone
+  #     # is sufficient, same as today).
+  #     require_labels: []

{ctrlrelay-0.4.1 → ctrlrelay-0.7.0}/docs/configuration.md

@@ -200,6 +200,7 @@ and ask the operator), or `never` (skip).
 | `accept_foreign_assignments` | `false` | When `true`, the poller also picks up issues assigned to you by someone else. Default (`false`) runs the dev pipeline only on issues you self-assigned. |
 | `exclude_labels` | `["manual", "operator", "instruction"]` | Issue labels that tell the poller "this isn't for the agent". See [exclude_labels](#reposautomationexclude_labels) below. |
 | `include_labels` | `[]` | Issue labels that opt an issue **into** the dev pipeline regardless of who is (or isn't) assigned. See [include_labels](#reposautomationinclude_labels) below. |
+| `require_labels` | `[]` | Issue labels that gate the plain-assignment trigger: when set, assignment alone is no longer enough — the issue must also carry one of these labels. See [require_labels](#reposautomationrequire_labels) below. |
 
 The current secops and dev pipelines read these settings to bias their prompts
 to Claude — they're not enforced by hard-coded checks.
@@ -308,6 +309,42 @@ triage access was already able to push branches and trigger CI, so allowing
 them to opt an issue into the dev pipeline is a narrower extension, not a new
 vector.
 
+### repos[].automation.require_labels
+
+Assignment-only ends up too loose on repos with a long history: issues
+self-assigned as personal reminders or notes, unrelated to automation, get
+replayed into the dev pipeline the first time the poller sees the repo (or
+after any config change that clears `poller_state.json` for it). Some of
+those issues aren't code tasks at all — "create an account with a
+third-party service", "look into pricing" — and shouldn't go anywhere near
+an unsupervised `claude -p ... --dangerously-skip-permissions` run.
+
+`require_labels` closes that gap: when configured, bare assignment is no
+longer sufficient by itself. An issue must be **both** assigned to the
+operator **and** carry at least one of the configured labels to be picked
+up via the assignment path.
+
+```yaml
+repos:
+  - name: "your-org/your-repo"
+    local_path: "~/Projects/your-repo"
+    automation:
+      require_labels: ["ctrlrelay:auto"]
+```
+
+- Default: `[]`. An empty list preserves today's behavior — assignment
+  alone is sufficient, no change for operators who haven't opted in.
+- Matching is **case-insensitive**, same as `exclude_labels` / `include_labels`.
+- This only tightens the **assignment** path. `include_labels` is
+  unaffected — a label match there still admits the issue regardless of
+  `require_labels`, since that path already treats the label as its own
+  trust signal.
+- An issue that's assigned but missing the required label is left
+  **unmarked** (not added to `seen_issues`), so applying the label later
+  still surfaces it on a subsequent poll — nothing is lost, it's just not
+  picked up yet.
+- `exclude_labels` is still checked first, same precedence as always.
+
 ## schedules
 
 In-process cron jobs run by the poller daemon. All expressions are

{ctrlrelay-0.4.1 → ctrlrelay-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ctrlrelay"
-version = "0.4.1"
+version = "0.7.0"
 description = "Local-first orchestrator for headless coding agents across multiple GitHub repos"
 readme = "README.md"
 requires-python = ">=3.12"

{ctrlrelay-0.4.1 → ctrlrelay-0.7.0}/src/ctrlrelay/cli.py

@@ -593,6 +593,29 @@ def run_secops(
     console.print(f"Running secops on {len(repos)} repo(s)...")
 
     async def _run():
+        # Build a transport so secops blocked questions reach Telegram.
+        # Without this, agents that end BLOCKED_NEEDS_INPUT silently land
+        # in the DB+pending_resumes and the operator never sees the
+        # question (mirror of the wiring in the scheduled path).
+        transport = None
+        if (
+            config.transport.type.value == "telegram"
+            and config.transport.telegram
+        ):
+            from ctrlrelay.transports import SocketTransport
+            sock = config.transport.telegram.socket_path.expanduser().resolve()
+            if sock.exists():
+                try:
+                    candidate = SocketTransport(sock)
+                    await candidate.connect()
+                    transport = candidate
+                except Exception as e:
+                    console.print(
+                        f"[yellow]Bridge transport connect failed ({e}) — "
+                        f"running without notifications. Blocked sessions "
+                        f"will land in pending_resumes for later resume.[/yellow]"
+                    )
+
         return await run_secops_all(
             repos=repos,
             dispatcher=dispatcher,
@@ -600,7 +623,7 @@ def run_secops(
             worktree=worktree,
             dashboard=dashboard,
             state_db=db,
-            transport=None,
+            transport=transport,
             contexts_dir=config.paths.contexts,
         )
 
@@ -1032,6 +1055,9 @@ def poller_start(
         include_labels_by_repo = {
             r.name: list(r.automation.include_labels) for r in config.repos
         }
+        require_labels_by_repo = {
+            r.name: list(r.automation.require_labels) for r in config.repos
+        }
 
         poller = IssuePoller(
             github=github,
@@ -1041,6 +1067,7 @@ def poller_start(
             accept_foreign_assignments=accept_foreign,
             exclude_labels_by_repo=exclude_labels_by_repo,
             include_labels_by_repo=include_labels_by_repo,
+            require_labels_by_repo=require_labels_by_repo,
         )
 
         # NOTE: first-run seeding moved into `_main()` so the APScheduler
@@ -1591,6 +1618,7 @@ def poller_start(
 
                     try:
                         if pipeline_name == "secops":
+                            sweep_repo_cfg = repo_cfg_by_name.get(repo)
                             result = await resume_secops_from_pending(
                                 session_id=session_id,
                                 repo=repo,
@@ -1602,6 +1630,12 @@ def poller_start(
                                 state_db=state_db,
                                 transport=sweeper_transport,
                                 contexts_dir=config.paths.contexts,
+                                automation=(
+                                    sweep_repo_cfg.automation
+                                    if sweep_repo_cfg is not None
+                                    else None
+                                ),
+                                question=row.get("question"),
                             )
                         elif pipeline_name == "dev":
                             # Dev resume needs the repo's branch template
@@ -2457,6 +2491,14 @@ def setup(
     )
     if result.personalization_summary:
         console.print(f"  personalization: {result.personalization_summary}")
+    if result.personalization_failed:
+        console.print(
+            "\n[bold red]ACTION NEEDED[/bold red] — personalization repo "
+            "sync failed; the rest of setup completed but your "
+            "personalization config/skills were not cloned. Check your "
+            "git auth (`gh auth status`, `gh config get git_protocol`) "
+            "and re-run `ctrlrelay personalization init` once it's fixed."
+        )
     if result.daemon_units:
         console.print("  daemon unit files:")
         for p in result.daemon_units:
@@ -2468,11 +2510,10 @@ def setup(
             "  systemctl --user daemon-reload && systemctl --user enable --now <unit>"
             "    # Linux"
         )
-    # Clone failures must surface as a non-zero exit even when daemon
-    # units were rendered — automation watching exit code shouldn't
-    # mistake a partial setup for success. Codex review pass 3 caught
-    # the prior `elif` that masked this.
-    if result.failed:
+    # Clone and personalization-sync failures must surface as a
+    # non-zero exit even when daemon units were rendered — automation
+    # watching exit code shouldn't mistake a partial setup for success.
+    if result.failed or result.personalization_failed:
         raise typer.Exit(1)
 
 

{ctrlrelay-0.4.1 → ctrlrelay-0.7.0}/src/ctrlrelay/core/config.py

@@ -183,6 +183,16 @@ class AutomationConfig(BaseModel):
     # Matching is case-insensitive. An issue that is both labeled AND
     # assigned is processed exactly once — not duplicated. See #80.
     include_labels: list[str] = Field(default_factory=list)
+    # Labels that gate the plain-assignment trigger. Default ``[]``
+    # preserves today's behavior (assignment alone is sufficient).
+    # When non-empty, bare assignment is no longer enough on its own:
+    # an issue must be assigned to the operator AND carry at least one
+    # of these labels to be picked up. This only tightens the
+    # assignment path — ``include_labels`` keeps triggering on label
+    # match alone regardless of ``require_labels``, and
+    # ``exclude_labels`` is still checked first. Matching is
+    # case-insensitive. See #139.
+    require_labels: list[str] = Field(default_factory=list)
     # Labels that route an issue to the task pipeline (run a command /
     # investigate / report findings via issue comment) instead of the
     # dev pipeline (branch + PR). Matching is case-insensitive; the

{ctrlrelay-0.4.1 → ctrlrelay-0.7.0}/src/ctrlrelay/core/poller.py

@@ -84,6 +84,16 @@ class IssuePoller:
     or ``seen_issues``). A repo with an empty / missing ``include_labels``
     keeps the pre-#80 ``--assignee``-filtered query so we don't
     over-fetch.
+
+    ``require_labels_by_repo`` tightens the plain-assignment trigger
+    (see #139). When a repo has any require-labels configured, bare
+    assignment is no longer sufficient by itself — an issue must be
+    assigned to the operator AND carry at least one of the configured
+    labels to be admitted via the assignment path. ``include_labels``
+    is unaffected: a label_match there still admits the issue
+    regardless of ``require_labels``. An issue that's assigned but
+    missing the required label is left unmarked (not seen) so a later
+    label addition still surfaces it on a subsequent poll.
     """
 
     github: GitHubCLI
@@ -94,6 +104,7 @@ class IssuePoller:
     accept_foreign_assignments: set[str] = field(default_factory=set)
     exclude_labels_by_repo: dict[str, list[str]] = field(default_factory=dict)
     include_labels_by_repo: dict[str, list[str]] = field(default_factory=dict)
+    require_labels_by_repo: dict[str, list[str]] = field(default_factory=dict)
     # Per-repo consecutive-skip counter; populated at runtime by poll() /
     # seed_current(). Not persisted — intentionally resets on daemon
     # restart so an operator fix is exercised before we re-escalate.
@@ -343,6 +354,10 @@ class IssuePoller:
                 label.lower()
                 for label in self.exclude_labels_by_repo.get(repo, [])
             }
+            require_lowered = {
+                label.lower()
+                for label in self.require_labels_by_repo.get(repo, [])
+            }
             for issue in issues:
                 # Per-issue guard so ONE malformed payload (missing 'number',
                 # wrong type, non-dict entry) doesn't poison the remaining
@@ -412,6 +427,18 @@ class IssuePoller:
                         is_assigned = self._issue_is_assigned_to(
                             issue, self.username,
                         )
+                    if (
+                        is_assigned
+                        and require_lowered
+                        and self._matched_require_label(
+                            issue, require_lowered,
+                        ) is None
+                    ):
+                        # Assigned but missing the required label
+                        # (#139): the plain-assignment trigger doesn't
+                        # count on this repo. label_match (below) can
+                        # still admit the issue independently.
+                        is_assigned = False
                     if label_match is None and not is_assigned:
                         # Defensive: a targeted query should never
                         # return an issue that matches neither trigger,
@@ -423,7 +450,13 @@ class IssuePoller:
                 else:
                     # Server-side ``--assignee`` already filtered; by
                     # construction every issue reaching here is
-                    # assignment-triggered.
+                    # assignment-triggered — unless require_labels
+                    # (#139) is configured, in which case the missing
+                    # label leaves the issue unmarked for a later poll.
+                    if require_lowered and self._matched_require_label(
+                        issue, require_lowered,
+                    ) is None:
+                        continue
                     is_assigned = True
 
                 if label_match is not None:
@@ -584,6 +617,27 @@ class IssuePoller:
                 return name
         return None
 
+    @staticmethod
+    def _matched_require_label(
+        issue: dict[str, Any], require_lowered: set[str]
+    ) -> str | None:
+        """Return the first issue label that matches ``require_lowered``.
+
+        Mirrors ``_matched_exclude_label`` / ``_matched_include_label``.
+        Used to gate the plain-assignment trigger when a repo has
+        ``require_labels`` configured. See #139.
+        """
+        if not require_lowered:
+            return None
+        for label in issue.get("labels") or []:
+            if isinstance(label, dict):
+                name = label.get("name", "")
+            else:
+                name = str(label)
+            if name and name.lower() in require_lowered:
+                return name
+        return None
+
     @staticmethod
     def _issue_is_assigned_to(issue: dict[str, Any], username: str) -> bool:
         """Check whether ``username`` is listed in the issue's assignees.
@@ -726,6 +780,10 @@ class IssuePoller:
             self._clear_repo_failure(repo)
             seen_for_repo = self.seen_issues.setdefault(repo, set())
             include_lowered = {label.lower() for label in include_labels}
+            require_lowered = {
+                label.lower()
+                for label in self.require_labels_by_repo.get(repo, [])
+            }
             for issue in issues:
                 try:
                     number = int(issue["number"])
@@ -776,11 +834,25 @@ class IssuePoller:
                         seen_for_repo.add(number)
                         continue
                     if self_assigned:
+                        if require_lowered and self._matched_require_label(
+                            issue, require_lowered,
+                        ) is None:
+                            # Assigned but missing the required label
+                            # (#139): leave unseeded so a later
+                            # label-add still surfaces it on the next
+                            # poll.
+                            continue
                         seen_for_repo.add(number)
                 else:
                     # Pre-#80 behavior: server-side --assignee already
                     # filtered, seed everything so first poll doesn't
-                    # flood.
+                    # flood — unless require_labels (#139) is
+                    # configured, in which case an issue missing the
+                    # required label is left unseeded.
+                    if require_lowered and self._matched_require_label(
+                        issue, require_lowered,
+                    ) is None:
+                        continue
                     seen_for_repo.add(number)
         self._save_state_best_effort()
 

{ctrlrelay-0.4.1 → ctrlrelay-0.7.0}/src/ctrlrelay/core/state.py

@@ -386,6 +386,80 @@ class StateDB:
         self._conn.commit()
         return cursor.rowcount > 0
 
+    # Automation decisions (operator answers persisted across sweeps)
+
+    def record_automation_decision(
+        self,
+        *,
+        repo: str,
+        operation: str,
+        item_id: str,
+        decision: str,
+        decided_by: str = "operator",
+        context: str | None = None,
+        policy: str = "",
+    ) -> None:
+        """Record an operator decision so future sweeps can avoid
+        re-asking the same question.
+
+        ``operation`` namespaces the decision domain
+        (e.g. ``"dependabot_pr"`` or ``"codeql_alert"``); ``item_id``
+        is the specific item the decision applies to (e.g. ``"#60"``
+        for PR #60). ``decision`` is the operator's verbatim answer —
+        the agent that reads this back interprets it; we don't try to
+        normalize to yes/no here because Telegram replies are free-form.
+        """
+        self._conn.execute(
+            """INSERT INTO automation_decisions
+               (repo, operation, policy, item_id, decision,
+                decided_by, decided_at, context)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
+            (repo, operation, policy, item_id, decision,
+             decided_by, int(time.time()), context),
+        )
+        self._conn.commit()
+
+    def list_recent_automation_decisions(
+        self,
+        repo: str,
+        *,
+        operation: str | None = None,
+        since_ts: int | None = None,
+        limit: int = 100,
+    ) -> list[dict[str, Any]]:
+        """Recent operator decisions for this repo, newest first.
+
+        ``operation`` namespaces the read so a Dependabot-PR consumer
+        only sees ``dependabot_pr`` rows, not e.g. ``codeql_alert``
+        decisions also tracked in the same repo. Without this filter,
+        a "suppress this CVE" answer for a CodeQL alert would render
+        into the Dependabot prompt as a prior-PR decision and the
+        agent could act on it. Defaults to ``None`` (all operations)
+        to preserve the original behaviour for callers that want a
+        full audit view.
+
+        ``since_ts`` (unix seconds) filters to decisions made
+        at-or-after that point — used by the secops prompt builder to
+        inject a 30-day rolling window into the agent's context so the
+        agent can act on prior decisions instead of asking again.
+        """
+        clauses = ["repo = ?"]
+        params: list[Any] = [repo]
+        if operation is not None:
+            clauses.append("operation = ?")
+            params.append(operation)
+        if since_ts is not None:
+            clauses.append("decided_at >= ?")
+            params.append(since_ts)
+        sql = (
+            "SELECT * FROM automation_decisions WHERE "
+            + " AND ".join(clauses)
+            + " ORDER BY decided_at DESC LIMIT ?"
+        )
+        params.append(limit)
+        rows = self._conn.execute(sql, tuple(params)).fetchall()
+        return [dict(row) for row in rows]
+
     # PR watches (durable, cross-restart)
 
     def add_pr_watch(