ctrlrelay 0.5.0__tar.gz → 0.8.0__tar.gz

{ctrlrelay-0.5.0 → ctrlrelay-0.8.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.5.0 → ctrlrelay-0.8.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.5.0 → ctrlrelay-0.8.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.5.0 → ctrlrelay-0.8.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.5.0 → ctrlrelay-0.8.0}/CHANGELOG.md

@@ -7,6 +7,110 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.8.0] - 2026-09-04
+
+### Added
+
+- **`ci_wait_timeout_seconds`: per-repo cap on the dev pipeline's
+  `ctrlrelay ci wait` call.** The dev pipeline prompt tells Claude to run
+  `ctrlrelay ci wait --pr <PR> --repo <repo> --timeout 600` before
+  signaling DONE — a single blocking call, hardcoded to 10 minutes, that
+  generates zero tokens while it polls GitHub. Measured directly on a real
+  session: two `ci wait` calls accounted for 12 of a 26-minute run, versus
+  under 35K output tokens generated the whole time — the wall-clock cost
+  is CI runtime, not model work. `ci_wait_timeout_seconds` (default `600`,
+  unchanged behavior) lets a repo with a faster CI suite cap that single
+  call lower instead of always budgeting the full 10 minutes.
+
+## [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
@@ -1143,7 +1247,10 @@ 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.8.0...HEAD
+[0.8.0]: https://github.com/AInvirion/ctrlrelay/compare/v0.7.0...v0.8.0
+[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.5.0 → ctrlrelay-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: ctrlrelay
-Version: 0.5.0
+Version: 0.8.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.5.0 → ctrlrelay-0.8.0}/config/orchestrator.yaml.example

@@ -139,3 +139,16 @@ 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: []
+  #     # Hard cap, in seconds, on the single `ctrlrelay ci wait` call the
+  #     # dev pipeline prompt runs before signaling DONE. Lower this to
+  #     # match how long this repo's CI actually takes — no tokens are
+  #     # generated while blocked in this call, so a slow default here
+  #     # just adds idle wall-clock time. Defaults to 600 (10 minutes).
+  #     ci_wait_timeout_seconds: 600

{ctrlrelay-0.5.0 → ctrlrelay-0.8.0}/docs/configuration.md

@@ -200,6 +200,8 @@ 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. |
+| `ci_wait_timeout_seconds` | `600` | Hard cap, in seconds, on the single `ctrlrelay ci wait` call the dev pipeline prompt tells Claude to run before signaling DONE. See [ci_wait_timeout_seconds](#reposautomationci_wait_timeout_seconds) 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 +310,67 @@ 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.
+
+### repos[].automation.ci_wait_timeout_seconds
+
+The dev pipeline prompt tells Claude to run `ctrlrelay ci wait --pr <PR>
+--repo <repo> --timeout <N>` before signaling DONE — a single blocking call
+that polls GitHub every 15s until CI finishes, fails, or the timeout hits.
+No tokens get generated while it's blocked; on a repo with a slow CI suite,
+that one call can eat most of a session's wall-clock time.
+
+```yaml
+repos:
+  - name: "your-org/your-repo"
+    local_path: "~/Projects/your-repo"
+    automation:
+      ci_wait_timeout_seconds: 300
+```
+
+- Default: `600` (10 minutes).
+- Lower it to match how long the repo's CI actually takes — a repo with a
+  2-minute CI suite gains nothing from a 10-minute cap.
+- A timeout here isn't a failure: `ctrlrelay ci wait` exits 2 (not 1) when
+  the deadline hits with checks still pending, and the prompt tells Claude
+  to treat that as acceptable and hand off rather than loop.
+- This does not change the overall session timeout (`agent.default_timeout_seconds`,
+  default 1800s) — it only bounds the one `ci wait` call.
+
 ## schedules
 
 In-process cron jobs run by the poller daemon. All expressions are

{ctrlrelay-0.5.0 → ctrlrelay-0.8.0}/pyproject.toml

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

{ctrlrelay-0.5.0 → ctrlrelay-0.8.0}/src/ctrlrelay/cli.py

@@ -748,6 +748,7 @@ def run_dev(
             state_db=db,
             transport=None,
             contexts_dir=config.paths.contexts,
+            ci_wait_timeout_seconds=repo_config.automation.ci_wait_timeout_seconds,
         )
 
     try:
@@ -1055,6 +1056,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,
@@ -1064,6 +1068,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
@@ -1269,6 +1274,7 @@ def poller_start(
                         state_db=state_db,
                         transport=connected_transport,
                         contexts_dir=config.paths.contexts,
+                        ci_wait_timeout_seconds=repo_config.automation.ci_wait_timeout_seconds,
                     )
 
                 # Lock-conflict retry hook. The poller marks issues seen
@@ -1631,6 +1637,7 @@ def poller_start(
                                     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
@@ -2486,6 +2493,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:
@@ -2497,11 +2512,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.5.0 → ctrlrelay-0.8.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
@@ -191,6 +201,13 @@ class AutomationConfig(BaseModel):
     # precedence so "not for the agent at all" overrides "agent does
     # this but differently".
     task_labels: list[str] = Field(default_factory=lambda: ["task"])
+    # Hard cap, in seconds, on a single `ctrlrelay ci wait` call the dev
+    # pipeline prompt tells Claude to run before signaling DONE. A repo
+    # with slow CI can eat most of a session's wall-clock time sitting
+    # in this one blocking call generating zero tokens; a fast-CI repo
+    # doesn't need anywhere near the 600s default. Lower this per-repo
+    # to match how long that repo's CI actually takes.
+    ci_wait_timeout_seconds: int = 600
 
 
 _REPO_NAME_RE = re.compile(r"^[A-Za-z0-9._-]+/[A-Za-z0-9._-]+$")

{ctrlrelay-0.5.0 → ctrlrelay-0.8.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.5.0 → ctrlrelay-0.8.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(

ctrlrelay-0.8.0/src/ctrlrelay/gh_protocol.py

@@ -0,0 +1,47 @@
+"""Detect the git transport protocol the operator has configured for
+GitHub via the ``gh`` CLI.
+
+``ctrlrelay`` clones a handful of GitHub repos on the operator's
+behalf (project repos, the personalization repo). Hardcoding HTTPS
+for these clones breaks operators who've set ``gh config set
+git_protocol ssh`` and have no HTTPS credential helper wired up —
+``git`` then fails with "could not read Username" instead of using
+the SSH key ``gh`` already knows about.
+"""
+
+from __future__ import annotations
+
+import subprocess
+
+_VALID_PROTOCOLS = ("ssh", "https")
+
+
+def detect_git_protocol(*, default: str = "https") -> str:
+    """Return ``"ssh"`` or ``"https"``, per ``gh config get git_protocol``.
+
+    Falls back to ``default`` whenever ``gh`` isn't installed, isn't
+    configured, or returns something unexpected — this is a
+    convenience read, not a hard requirement, so any failure here
+    should degrade to the previous hardcoded-HTTPS behavior rather
+    than blocking a clone.
+    """
+    try:
+        proc = subprocess.run(
+            ["gh", "config", "get", "git_protocol"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return default
+    value = proc.stdout.strip().lower()
+    if proc.returncode == 0 and value in _VALID_PROTOCOLS:
+        return value
+    return default
+
+
+def github_clone_url(repo: str, *, protocol: str) -> str:
+    """Build a clone URL for ``owner/repo`` under the given protocol."""
+    if protocol == "ssh":
+        return f"git@github.com:{repo}.git"
+    return f"https://github.com/{repo}.git"

{ctrlrelay-0.5.0 → ctrlrelay-0.8.0}/src/ctrlrelay/install.py

@@ -178,7 +178,17 @@ def write_units(
     silently overwriting an operator's customised plist would be a foot-gun.
     Returns the list of paths actually written. Raises ``FileExistsError``
     if any target exists and overwrite is False.
+
+    Also ensures ``~/.ctrlrelay/logs/`` exists — both the launchd and
+    systemd templates set StandardOutput/StandardError paths under it,
+    and systemd refuses to start a unit at all (EXIT_STDOUT, code 209)
+    when the directory is missing; combined with ``Restart=always``
+    that's an immediate crash-loop (#137).
+
+    Unit files are chmod'd ``0600`` after writing since they embed
+    ``CTRLRELAY_TELEGRAM_TOKEN`` as plaintext.
     """
+    (Path.home() / ".ctrlrelay" / "logs").mkdir(parents=True, exist_ok=True)
     written: list[Path] = []
     for unit in units:
         unit.target_path.parent.mkdir(parents=True, exist_ok=True)
@@ -188,5 +198,6 @@ def write_units(
                 "pass --force to replace it"
             )
         unit.target_path.write_text(unit.content, encoding="utf-8")
+        unit.target_path.chmod(0o600)
         written.append(unit.target_path)
     return written