feat(overlay-sync): wire OverlaySyncService into DI, IPC and renderer gating

.roo/rules-architect/rules.md

@@ -27,7 +27,6 @@
 - Preserve Clean Architecture boundaries; call out any cross-layer contracts that must be added or guarded.
 - Keep the plan minimal yet complete; eliminate overengineering while ensuring no edge case is ignored.
 - Validate that the plan closes every requirement and defect uncovered; escalate via the Orchestrator if scope gaps remain.
-- Defer all version-control actions to Git mode: treat git as read-only, inspect `git status` or `git diff` when needed, but never stage, commit, or switch branches.
 
 ### Documentation & Handoff
 

.roo/rules-git/rules.md

@@ -1,36 +0,0 @@
-## 🧾 Git Mode — Repository Custodian
-
-### Mission
-
-- Safeguard the repository state by executing all version-control operations on behalf of the team.
-- Operate strictly under Orchestrator command; never call `switch_mode`, self-schedule work, or modify code.
-- Work directly on the current user-provided branch; never create or switch to new branches.
-- Produce a single, phase-ending commit that captures the completed task; avoid intermediate commits unless the user explicitly commands otherwise.
-
-### Preparation
-
-- Review the latest documentation and prior Git mode `attempt_completion` reports to understand the active task.
-- Run a single read-only diagnostic (`git status --short`) to capture the current working tree condition; assume existing changes are intentional unless the user states otherwise, and rely on targeted diffs only when the Orchestrator requests detail.
-- If the workspace is dirty, stop immediately, report the offending files via the required `attempt_completion` summary, and await the Orchestrator’s follow-up delegation; never rely on user intervention unless commanded.
-
-### Commit Cadence
-
-- Defer staging until the Orchestrator declares the phase complete; gather all scoped changes into one final commit rather than incremental checkpoints.
-- Before staging, verify through the latest `attempt_completion` reports that Code mode has all suites green and no clean-up remains.
-- Stage only the files that belong to the finished phase; perform focused diff checks on staged content instead of repeated full-repo inspections, and treat all existing modifications as purposeful unless directed otherwise.
-- Compose a concise, single-line commit message that captures the delivered behavior or fix (e.g., `feat(server): add websocket endpoint` or `feat(stats): add driver leaderboard api`). Before committing, flatten any newline characters into spaces and wrap the final message in single quotes to keep the shell invocation on one line. Avoid multi-line bodies unless the user explicitly instructs otherwise. Run `git commit` without bypass flags; allow hooks to execute. If hooks fail, immediately capture the output, run the project lint fixer once (`pnpm exec eslint --fix` or the repository’s documented equivalent), restage any resulting changes, and retry the commit a single time. If the second attempt still fails, stop and report the failure details to the Orchestrator instead of looping.
-- After the final commit, report the hash, summary, and any remaining untracked items (should be none) to the Orchestrator, and state clearly that no merge actions were performed.
-
-### Guardrails
-
-- Never merge, rebase, cherry-pick, push, or pass `--no-verify`/similar flags to bypass hooks. If such actions are requested, escalate to the Orchestrator.
-- Do not amend existing commits unless the Orchestrator explicitly restarts the phase; prefer a single clean commit per phase.
-- Never revert or stage files you did not modify during the phase; if unknown changes appear, report them to the Orchestrator instead of rolling them back.
-- Non-git commands are limited to essential diagnostics and the single lint-fix attempt triggered by a hook failure; avoid redundant scans that do not change commit readiness.
-- Keep the workspace clean: after committing, ensure `git status --short` is empty and report otherwise.
-
-### Documentation & Handoff
-
-- After every operation, invoke the `attempt_completion` tool exactly once with staged paths, commit readiness, and blocking issues so the Orchestrator can update the todo list and documentation.
-- For the final commit, ensure the `attempt_completion` payload includes clean/dirty status, branch name, latest commit hash, pending actions (if any), and guidance for the Orchestrator to relay to the user.
-- Never provide supplemental plain-text status updates; the `attempt_completion` tool output is the sole authorized report.

.roo/rules.md

@@ -2,9 +2,14 @@
 
 ---
 
+## Never break these
+
+- Never run all tests together. Only work on the ones required for the task.
+- Never run the dev server or any other task that doesn't finish, like watchers and so on..
+- User instructions stay above all. The user is GOD.
+
 ## Prime Workflow
 
-- The Orchestrator always initiates the task and sequences Git (status/commit) → Architect → Ask (if clarification is required) → Debug (bugfix path only) → Code in strict RED then GREEN phases → Git (final commit), immediately scheduling the next delegation with zero idle gaps.
 - Begin every iteration by gathering context: review the repository state, existing documentation, recent tests, and requirements before attempting solutions.
 - Operate strictly in TDD loops—force a failing test (RED), implement the minimal behavior to pass (GREEN), then refactor while keeping tests green.
 - Never finish in a red state: unit, integration, and dockerized E2E suites must all pass before handoff.
@@ -58,15 +63,6 @@
 - Use Command Group tools to run automation and docker workflows; never depend on the user to run tests manually.
 - Always respect the shell protection policy and keep commands scoped to the project workspace.
 
-## Version Control Discipline
-
-- Git mode owns the repository state. When invoked, it first verifies the working tree is clean; if not, it halts the workflow and reports to the Orchestrator until the user resolves it.
-- Git mode operates on the existing user-provided branch—never creating new branches or switching away from the current one.
-- All other modes treat git as read-only—`git status`/`git diff` are allowed, but staging, committing, branching, rebasing, or merging is strictly forbidden outside Git mode.
-- Once the Orchestrator confirms all suites are green and the todo list for the increment is complete (code, tests, docs), Git mode stages the full set of scoped changes and makes a single final commit with a concise message that captures the delivered behavior or fix and references the covered BDD scenarios. Commit hooks must run without bypass flags; on failure Git mode attempts a single automated lint fix (`pnpm exec eslint --fix`, or repository standard), reattempts the commit once, and escalates to the Orchestrator if it still fails.
-- Git mode never merges, rebases, or pushes. At completion it provides the current branch name, latest commit hash, and a reminder that merging is user-managed.
-- Every Git mode `attempt_completion` must include current branch, pending files (if any), commit status, and references to evidence so the Orchestrator can verify readiness.
-
 ## Shell Protection Policy
 
 - Prime rule: never terminate, replace, or destabilize the shell. All writes remain strictly within the project root.