From 777a9b4b312c63e73551cca4dbbfaae679673da4 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Tue, 13 Jan 2026 17:16:20 +0100
Subject: [PATCH 01/63] Auto-commit local changes before build (2026-01-13
 17:16:20)

---
 ...k_integration_functional_design_phase_1.md | 234 ++++++++++++++++++
 1 file changed, 234 insertions(+)
 create mode 100644 docs/backupchecks_autotask_integration_functional_design_phase_1.md

diff --git a/docs/backupchecks_autotask_integration_functional_design_phase_1.md b/docs/backupchecks_autotask_integration_functional_design_phase_1.md
new file mode 100644
index 0000000..f07dd7a
--- /dev/null
+++ b/docs/backupchecks_autotask_integration_functional_design_phase_1.md
@@ -0,0 +1,234 @@
+# Backupchecks – Autotask Integration
+
+## Functional Design – Phase 1
+
+_Last updated: 2026-01-13_
+
+---
+
+## 1. Scope & Goals
+
+This document describes the **functional design and agreed decisions** for the first phase of the Autotask integration in Backupchecks.
+
+Goals for phase 1:
+- Allow operators to **manually create Autotask tickets** from Backupchecks.
+- Ensure **full operator control** over when a ticket is created.
+- Prevent ticket spam and duplicate tickets.
+- Maintain clear ownership between Backupchecks and Autotask.
+- Provide a safe and auditable way to resolve tickets from Backupchecks.
+
+Out of scope for phase 1:
+- Automatic ticket creation
+- Automatic ticket closing on success
+- Issue correlation across multiple runs
+- Time entry creation or modification
+
+---
+
+## 2. Core Principles (Leading)
+
+These principles apply to all design and implementation choices:
+
+- Autotask is an **external authoritative system** (PSA).
+- Backupchecks is a **consumer**, not an owner, of PSA data.
+- **IDs are leading**, names are display-only.
+- All PSA mappings are **explicit**, never implicit or automatic.
+- Operators always retain **manual control**.
+- Renaming in Autotask must **never break mappings**.
+
+---
+
+## 3. Customer ↔ Autotask Company Mapping
+
+### 3.1 Mapping model
+
+- Mapping is configured in the **Customers** screen.
+- Mapping is a **1-to-1 explicit relationship**.
+- Stored values per customer:
+  - PSA type: `autotask`
+  - Autotask Company ID (leading)
+  - Autotask Company Name (cached for display)
+  - Last sync timestamp
+  - Mapping status: `ok | renamed | missing | invalid`
+
+> **Note:** The Autotask Company ID is the source of truth. The name exists only for UI clarity.
+
+### 3.2 Name synchronisation
+
+- If the company name is changed in Autotask:
+  - Backupchecks updates the cached name automatically.
+  - The mapping remains intact.
+- Backupchecks customer names are **independent** and never overwritten.
+
+### 3.3 Failure scenarios
+
+- Autotask company deleted or inaccessible:
+  - Mapping status becomes `invalid`.
+  - Ticket creation is blocked.
+  - UI clearly indicates broken mapping.
+
+---
+
+## 4. Ticket Creation Model
+
+### 4.1 Operator-driven creation
+
+- Tickets are created **only** via an explicit operator action.
+- Location: **Run Checks** page.
+- Manual ticket number input is removed.
+- A new action replaces it:
+  - **“Create Autotask ticket”**
+
+> **Rationale:** There are too many backup alerts that do not require a ticket. Human judgement remains essential.
+
+### 4.2 One ticket per run (Key decision)
+
+- **Exactly one ticket per Run**.
+- A run can never create multiple tickets.
+- If a ticket exists:
+  - Creation action is replaced by:
+    - “Open ticket”
+    - (Later) “Add note”
+
+> **Rationale:** Multiple errors within a run often share the same root cause. This prevents ticket flooding.
+
+### 4.3 Ticket contents (baseline)
+
+Minimum ticket fields:
+- Subject:
+  - `[Backupchecks] <Customer> - <Job> - <Status>`
+- Description:
+  - Run date/time
+  - Backup type and job
+  - Affected objects (e.g. HV01, USB Disk)
+  - Error / warning messages
+  - Reference to Backupchecks (URL or identifier)
+
+Optional (configurable later):
+- Queue
+- Issue type / category
+- Priority mapping
+
+---
+
+## 5. Ticket State Tracking in Backupchecks
+
+Per Run, Backupchecks stores:
+- Autotask Ticket ID
+- Autotask Ticket Number
+- Ticket URL (optional)
+- Created by (operator)
+- Created at timestamp
+- Last known ticket status (snapshot)
+
+This ensures:
+- No duplicate tickets
+- Full audit trail
+- Clear operator feedback
+
+---
+
+## 6. Ticket Resolution from Backupchecks
+
+### 6.1 Resolution policy
+
+Backupchecks **may resolve** an Autotask ticket **only if**:
+- The ticket exists
+- The ticket is not already closed
+- **No time entries are present on the ticket**
+
+This rule is **mandatory and non-configurable**.
+
+> **Rationale:** Prevents financial and operational conflicts inside Autotask.
+
+### 6.2 Operator experience
+
+- Resolve action is visible only if conditions are met.
+- If time entries exist:
+  - Resolve action is hidden or disabled
+  - Clear message is shown to the operator
+
+### 6.3 Closing note (fixed text)
+
+When resolving a ticket, Backupchecks always adds the following note **before closing**:
+
+> `Ticket resolved via Backupchecks after verification that the backup issue is no longer present.`
+
+Characteristics:
+- Fixed text (no operator editing in phase 1)
+- System / internal note (not customer-facing)
+- Ensures auditability and clarity
+
+---
+
+## 7. Backupchecks Settings
+
+### 7.1 New settings section
+
+**Settings → Extensions & Integrations → Autotask**
+
+### 7.2 Required settings
+
+- Enable Autotask integration (on/off)
+- Environment: Sandbox / Production
+- API Username
+- API Password
+- Tracking Identifier
+
+### 7.3 Optional / recommended settings
+
+- Default ticket queue
+- Default issue type / category
+- Priority mapping (Error vs Warning)
+- Default new ticket status
+
+### 7.4 Resolve configuration
+
+- Allow resolving tickets from Backupchecks (on/off)
+- Closing note text (read-only, fixed)
+
+### 7.5 Validation & diagnostics
+
+- Test connection
+- Validate configuration
+- Optional API logging level
+
+> **Note:** Customer mapping is intentionally **not** part of global settings.
+
+---
+
+## 8. Roles & Permissions
+
+- Admin / Operator:
+  - Create tickets
+  - Resolve tickets (if allowed)
+- Reporter:
+  - View ticket number and link
+  - No create or resolve actions
+
+---
+
+## 9. Explicit Non-Goals (Phase 1)
+
+The following are explicitly excluded:
+- Automatic ticket creation
+- Automatic ticket closing
+- Updating ticket content after creation
+- Multiple tickets per run
+- Time entry handling
+- Multi-PSA support
+
+---
+
+## 10. Phase 1 Summary
+
+Phase 1 delivers:
+- Safe, controlled PSA integration
+- Operator-driven ticket lifecycle
+- Clear audit trail
+- Minimal risk to Autotask data integrity
+
+This design intentionally prioritises **predictability and control** over automation.
+
+Future phases may build on this foundation.
+

From 48e7830957d9fece372efa03acdc4c5cad8562e9 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Thu, 15 Jan 2026 09:37:33 +0100
Subject: [PATCH 02/63] Auto-commit local changes before build (2026-01-15
 09:37:33)

---
 ...k_integration_functional_design_phase_1.md | 274 ++++++++++++++++--
 ...sk_integration_implementation_breakdown.md | 205 +++++++++++++
 2 files changed, 457 insertions(+), 22 deletions(-)
 create mode 100644 docs/backupchecks_autotask_integration_implementation_breakdown.md

diff --git a/docs/backupchecks_autotask_integration_functional_design_phase_1.md b/docs/backupchecks_autotask_integration_functional_design_phase_1.md
index f07dd7a..0575753 100644
--- a/docs/backupchecks_autotask_integration_functional_design_phase_1.md
+++ b/docs/backupchecks_autotask_integration_functional_design_phase_1.md
@@ -124,7 +124,77 @@ Per Run, Backupchecks stores:
 This ensures:
 - No duplicate tickets
 - Full audit trail
-- Clear operator feedback
+n- Clear operator feedback
+
+---
+
+## 5A. Ticket Content Composition Rules
+
+This chapter defines how Backupchecks determines **what content is placed in an Autotask ticket**, with the explicit goal of keeping tickets readable and actionable.
+
+### 5A.1 Guiding principle
+
+- A ticket is a **signal**, not a log file.
+- The ticket must remain readable for the ticket owner.
+- Full technical details always remain available in Backupchecks.
+
+### 5A.2 Content hierarchy (deterministic)
+
+Backupchecks applies the following strict hierarchy when composing ticket content:
+
+1. **Overall remark** (run-level summary) – if present, this is leading.
+2. **Object-level messages** – used only when no overall remark exists.
+
+This hierarchy is fixed and non-configurable in phase 1.
+
+### 5A.3 Scenario A – Overall remark present
+
+If an overall remark exists for the run:
+- The ticket description contains:
+  - The overall remark
+  - Job name, run date/time, and status
+- Object-level errors are **not listed in full**.
+- A short informational line is added:
+  - “Multiple objects reported errors. See Backupchecks for full details.”
+
+> **Rationale:** The overall remark already represents a consolidated summary. Listing many objects would reduce ticket clarity.
+
+### 5A.4 Scenario B – No overall remark
+
+If no overall remark exists:
+- The ticket description includes object-level errors.
+- Object listings are **explicitly limited**:
+  - A maximum of *N* objects (exact value defined during implementation)
+- If more objects are present:
+  - “And X additional objects reported similar errors.”
+
+> **Rationale:** Prevents large, unreadable tickets while still providing concrete examples.
+
+### 5A.5 Mandatory reference to Backupchecks
+
+Every ticket created by Backupchecks must include a **direct link to the Job Details page of the originating run**.
+
+This link is intended as the primary navigation entry point for the ticket owner.
+
+The ticket description must include:
+- Job name
+- Run date/time
+- A clickable URL pointing to the Job Details page of that run in Backupchecks
+
+> **Rationale:** The Job Details page provides the most complete and structured context for investigation.
+
+This ensures:
+- Full traceability
+- Fast access to complete technical details
+
+---
+
+### 5A.6 Explicit exclusions
+
+The following content is deliberately excluded from ticket descriptions:
+- Complete object lists when large
+- Repeated identical error messages
+- Raw technical dumps or stack traces
 
 ---
 
@@ -141,23 +211,102 @@ This rule is **mandatory and non-configurable**.
 
 > **Rationale:** Prevents financial and operational conflicts inside Autotask.
 
-### 6.2 Operator experience
+### 6.2 Behaviour when time entries exist
 
-- Resolve action is visible only if conditions are met.
-- If time entries exist:
-  - Resolve action is hidden or disabled
-  - Clear message is shown to the operator
+If an operator clicks **Resolve ticket** but the ticket **contains time entries**:
+- The ticket **must not be closed** by Backupchecks.
+- Backupchecks **adds an internal system note** to the ticket stating that it was marked as resolved from Backupchecks.
+- The ticket remains open for the ticket owner to review and close manually.
+
+Proposed internal system note text:
+
+> `Ticket marked as resolved in Backupchecks, but not closed automatically because time entries are present.`
+
+> **Rationale:** Ensures the ticket owner is explicitly informed without violating Autotask process or financial controls.
 
 ### 6.3 Closing note (fixed text)
 
-When resolving a ticket, Backupchecks always adds the following note **before closing**:
+When resolving a ticket **and no time entries are present**, Backupchecks always adds the following **internal system note** **before closing**:
 
 > `Ticket resolved via Backupchecks after verification that the backup issue is no longer present.`
 
 Characteristics:
 - Fixed text (no operator editing in phase 1)
-- System / internal note (not customer-facing)
-- Ensures auditability and clarity
+- **System / internal note** (never customer-facing)
+- Ensures auditability and traceability
+
+---
+
+---
+
+## 6A. Handling Existing Tickets & Compatibility Mode
+
+### 6A.1 Existing manual ticket numbers
+
+In the pre-integration workflow, a run may already contain a manually entered ticket number.
+
+When Autotask integration is **enabled**:
+- Existing ticket numbers remain visible.
+- Backupchecks may offer a one-time action:
+  - **“Link existing Autotask ticket”**
+  - This validates the ticket in Autotask and stores the **Autotask Ticket ID**.
+
+> **Note:** Without an Autotask Ticket ID, Backupchecks must not attempt to resolve a ticket.
+
+When Autotask integration is **disabled**:
+- The current/manual workflow applies (manual ticket number entry).
+
+### 6A.2 Linking existing Autotask tickets
+
+When integration is enabled, operators can link an existing Autotask ticket to a run:
+- Search/select a ticket (preferably by ticket number)
+- Store:
+  - Autotask Ticket ID
+  - Autotask Ticket Number
+  - Ticket URL (optional)
+
+After linking:
+- The run behaves like an integration-created ticket for viewing and resolution rules.
+
+### 6A.3 Compatibility mode (optional setting)
+
+Optional setting (recommended for transition periods):
+- **“Allow manual ticket number entry when Autotask is enabled”** (default: OFF)
+
+Behaviour:
+- When ON, operators can still manually enter a ticket number even if integration is enabled.
+- Resolve from Backupchecks is still only possible for tickets that have a validated Autotask Ticket ID.
+
+> **Rationale:** Provides a safe escape hatch during rollout and migration.
+
+---
+
+## 6B. Deleted Tickets in Autotask
+
+Tickets may be deleted in Autotask. When a ticket referenced by Backupchecks is deleted, the linkage becomes invalid.
+
+### 6B.1 Detection
+
+When Backupchecks attempts to fetch the ticket by Autotask Ticket ID:
+- If Autotask returns “not found” (deleted/missing), Backupchecks marks the linkage as **broken**.
+
+### 6B.2 Behaviour when a ticket is deleted
+
+- The run keeps the historical reference (ticket number/ID) for audit purposes.
+- The ticket state is shown as:
+  - **“Missing in Autotask (deleted)”**
+- Actions are blocked:
+  - No “Open ticket” (if no valid URL)
+  - No “Resolve ticket”
+- Operators can choose:
+  - **Re-link to another ticket** (if the ticket was recreated or replaced)
+  - **Create a new Autotask ticket** (creates a new link for that run)
+
+> **Note:** Backupchecks should never silently remove the stored linkage, to preserve auditability.
+
+### 6B.3 Optional: periodic validation
+
+Optionally (later), Backupchecks may periodically validate linked ticket IDs and flag missing tickets.
 
 ---
 
@@ -175,26 +324,58 @@ Characteristics:
 - API Password
 - Tracking Identifier
 
-### 7.3 Optional / recommended settings
+### 7.3 Ticket creation defaults (configurable)
 
-- Default ticket queue
-- Default issue type / category
-- Priority mapping (Error vs Warning)
-- Default new ticket status
+These defaults are applied when Backupchecks creates a new Autotask ticket.
 
-### 7.4 Resolve configuration
+- Ticket Source (default): **Monitoring Alert**
+- Default Queue (default): **Helpdesk**
+- Default Status (default): **New**
+- Priority mapping:
+  - Warning → **Medium**
+  - Error → **High**
+
+> **Note:** Issue Type / Category is intentionally **not set** by Backupchecks and will be assigned by the ticket owner or traffic manager.
+
+---
+
+### 7.3A Backupchecks Base URL
+
+- Base URL of the Backupchecks instance (e.g. `https://backupchecks.example.com`)
+
+This value is required to construct:
+- Direct links to Job Details pages
+- Stable references inside Autotask tickets
+
+> **Note:** This setting is mandatory for ticket creation and must be validated.
+
+---
+
+### 7.4 Dynamic reference data
+
+Backupchecks must retrieve the following reference data from Autotask and present it in Settings:
+- Available Queues
+- Available Ticket Sources
+
+These lists are:
+- Loaded on demand (or via refresh action)
+- Stored for selection in Settings
+
+> **Rationale:** Prevents hard-coded values and keeps Backupchecks aligned with Autotask configuration changes.
+
+### 7.5 Resolve configuration
 
 - Allow resolving tickets from Backupchecks (on/off)
-- Closing note text (read-only, fixed)
+- Closing note texts (read-only, fixed):
+  - Standard resolve note
+  - Time-entry-blocked resolve note
 
-### 7.5 Validation & diagnostics
+### 7.6 Validation & diagnostics
 
 - Test connection
-- Validate configuration
+- Validate configuration (credentials, reference data access)
 - Optional API logging level
 
-> **Note:** Customer mapping is intentionally **not** part of global settings.
-
 ---
 
 ## 8. Roles & Permissions
@@ -208,11 +389,59 @@ Characteristics:
 
 ---
 
-## 9. Explicit Non-Goals (Phase 1)
+## 9. Handling Existing, Linked and Deleted Tickets
+
+### 9.1 Existing tickets (pre-integration)
+
+- Runs that already contain a manually entered ticket number remain valid.
+- When Autotask integration is enabled, operators may optionally:
+  - Link the run to an existing Autotask ticket (validated against Autotask).
+  - After linking, the run follows the same rules as integration-created tickets.
+
+> **Note:** This optional compatibility flow exists to support a gradual transition and avoids forced migration.
+
+### 9.2 Optional compatibility mode
+
+- Optional setting: **Allow manual ticket number entry when Autotask is enabled**
+- Default: OFF
+- Intended as a temporary transition mechanism.
+
+### 9.3 Deleted tickets in Autotask (important case)
+
+Tickets may be deleted directly in Autotask. Backupchecks must handle this safely and explicitly.
+
+Behaviour:
+- Backupchecks never assumes tickets exist based on stored data alone.
+- On any ticket-related action (view, resolve, open):
+  - Backupchecks validates the ticket ID against Autotask.
+
+If Autotask returns *not found*:
+- The ticket is marked as **Deleted (external)**.
+- The existing link is preserved as historical data but marked inactive.
+- No further actions (resolve, update) are allowed on that ticket.
+
+UI behaviour:
+- Ticket number remains visible with a clear indicator:
+  - “Ticket deleted in Autotask”
+- Operator is offered one explicit action:
+  - “Create new Autotask ticket” (results in a new ticket linked to the same run)
+
+> **Rationale:** Ticket deletion is an external administrative decision. Backupchecks records the fact but does not attempt to repair or hide it.
+
+### 9.4 Why links are not silently removed
+
+- Silent removal would break audit trails.
+- Historical runs must retain context, even if external objects no longer exist.
+- Operators must explicitly decide how to proceed.
+
+---
+
+## 10. Explicit Non-Goals (Phase 1)
 
 The following are explicitly excluded:
 - Automatic ticket creation
 - Automatic ticket closing
+- Automatic re-creation of deleted tickets
 - Updating ticket content after creation
 - Multiple tickets per run
 - Time entry handling
@@ -220,11 +449,12 @@ The following are explicitly excluded:
 
 ---
 
-## 10. Phase 1 Summary
+## 11. Phase 1 Summary
 
 Phase 1 delivers:
 - Safe, controlled PSA integration
 - Operator-driven ticket lifecycle
+- Explicit handling of legacy, linked and deleted tickets
 - Clear audit trail
 - Minimal risk to Autotask data integrity
 
diff --git a/docs/backupchecks_autotask_integration_implementation_breakdown.md b/docs/backupchecks_autotask_integration_implementation_breakdown.md
new file mode 100644
index 0000000..1fca3d2
--- /dev/null
+++ b/docs/backupchecks_autotask_integration_implementation_breakdown.md
@@ -0,0 +1,205 @@
+# Backupchecks – Autotask Integration
+
+## Implementation Breakdown & Validation Plan
+
+_Last updated: 2026-01-13_
+
+---
+
+## 1. Purpose of this document
+
+This document describes the **logical breakdown of the Autotask integration into implementation phases**.
+
+It is intended to:
+- Provide context at the start of each development chat
+- Keep focus on the **overall goal** while working step by step
+- Ensure each phase is independently testable and verifiable
+- Prevent scope creep during implementation
+
+This document complements:
+- *Backupchecks – Autotask Integration Functional Design (Phase 1)*
+
+---
+
+## 2. Guiding implementation principles
+
+- Implement in **small, validated steps**
+- Each phase must be:
+  - Testable in isolation
+  - Reviewable without knowledge of later phases
+- No UI or workflow assumptions beyond the current phase
+- Sandbox-first development
+- No breaking changes without explicit intent
+
+---
+
+## 3. Implementation phases
+
+### Phase 1 – Autotask integration foundation
+
+**Goal:** Establish a reliable, testable Autotask integration layer.
+
+Scope:
+- Autotask client/service abstraction
+- Authentication handling
+- Tracking Identifier usage
+- Environment selection (Sandbox / Production)
+- Test connection functionality
+- Fetch reference data:
+  - Queues
+  - Ticket Sources
+
+Out of scope:
+- UI integration (except minimal test hooks)
+- Ticket creation
+- Customer mapping
+
+Validation criteria:
+- Successful authentication against Sandbox
+- Reference data can be retrieved and parsed
+- Clear error handling for auth and API failures
+
+---
+
+### Phase 2 – Settings integration
+
+**Goal:** Persist and validate Autotask configuration in Backupchecks.
+
+Scope:
+- New Settings section:
+  - Extensions & Integrations → Autotask
+- Store:
+  - Enable/disable toggle
+  - Environment
+  - API credentials
+  - Tracking Identifier
+  - Backupchecks Base URL
+  - Ticket defaults (queue, source, priorities)
+- Dropdowns populated from live Autotask reference data
+- Test connection & refresh reference data actions
+
+Out of scope:
+- Customer mapping
+- Ticket creation
+
+Validation criteria:
+- Settings can be saved and reloaded
+- Invalid configurations are blocked
+- Reference data reflects Autotask configuration
+
+---
+
+### Phase 3 – Customer to Autotask company mapping
+
+**Goal:** Establish stable, ID-based customer mappings.
+
+Scope:
+- Customer screen enhancements
+- Search/select Autotask companies
+- Store company ID + cached name
+- Detect and reflect renamed or deleted companies
+- Mapping status indicators
+
+Out of scope:
+- Ticket creation
+- Run-level logic
+
+Validation criteria:
+- Mapping persists correctly
+- Renaming in Autotask does not break linkage
+- Deleted companies are detected and reported
+
+---
+
+### Phase 4 – Ticket creation from Run Checks
+
+**Goal:** Allow operators to create Autotask tickets from Backupchecks runs.
+
+Scope:
+- “Create Autotask ticket” action
+- Ticket payload composition rules
+- Priority mapping (Warning / Error)
+- Queue, source, status defaults
+- Job Details page link inclusion
+- Store ticket ID and number
+
+Out of scope:
+- Ticket resolution
+- Linking existing tickets
+
+Validation criteria:
+- Exactly one ticket per run
+- Tickets contain correct content and links
+- No duplicate tickets can be created
+
+---
+
+### Phase 5 – Ticket resolution flows
+
+**Goal:** Safely resolve tickets from Backupchecks.
+
+Scope:
+- Resolve without time entries:
+  - Internal note
+  - Close ticket
+- Resolve with time entries:
+  - Internal note only
+  - Ticket remains open
+- All notes stored as internal/system notes
+
+Out of scope:
+- Automatic resolution
+- Time entry creation
+
+Validation criteria:
+- Time entry checks enforced
+- Correct notes added in all scenarios
+- Ticket status reflects expected behaviour
+
+---
+
+### Phase 6 – Integration disable & compatibility behaviour
+
+**Goal:** Ensure safe fallback and migration support.
+
+Scope:
+- Disable Autotask integration globally
+- Restore manual ticket number workflow
+- Optional compatibility mode:
+  - Allow manual ticket number entry while integration enabled
+- Link existing Autotask tickets to runs
+
+Validation criteria:
+- No Autotask API calls when integration is disabled
+- Existing data remains visible
+- Operators can safely transition between workflows
+
+---
+
+## 4. Usage in development chats
+
+For each development chat:
+- Include this document
+- Include the Functional Design document
+- Clearly state:
+  - Current phase
+  - Current branch name
+  - Provided source/zip (if applicable)
+
+This ensures:
+- Shared context
+- Focused discussions
+- Predictable progress
+
+---
+
+## 5. Summary
+
+This breakdown ensures the Autotask integration is:
+- Predictable
+- Auditable
+- Incrementally delivered
+- Easy to reason about during implementation
+
+Each phase builds on the previous one without hidden dependencies.
+

From f6310da57521c31affcf0c1bb875bc50f1ed16b2 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Thu, 15 Jan 2026 10:12:09 +0100
Subject: [PATCH 03/63] Auto-commit local changes before build (2026-01-15
 10:12:09)

---
 .last-branch                                  |   2 +-
 .../app/integrations/autotask/__init__.py     |   0
 .../app/integrations/autotask/client.py       | 129 ++++++++++++++
 .../src/backend/app/main/routes_settings.py   | 166 ++++++++++++++++++
 .../src/backend/app/migrations.py             |  41 +++++
 .../backupchecks/src/backend/app/models.py    |  22 ++-
 .../src/templates/main/settings.html          |   3 +
 7 files changed, 361 insertions(+), 2 deletions(-)
 create mode 100644 containers/backupchecks/src/backend/app/integrations/autotask/__init__.py
 create mode 100644 containers/backupchecks/src/backend/app/integrations/autotask/client.py

diff --git a/.last-branch b/.last-branch
index 2da1383..2133928 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260113-08-vspc-object-linking-normalize
+v20260115-01-autotask-settings
diff --git a/containers/backupchecks/src/backend/app/integrations/autotask/__init__.py b/containers/backupchecks/src/backend/app/integrations/autotask/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/containers/backupchecks/src/backend/app/integrations/autotask/client.py b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
new file mode 100644
index 0000000..9eaa036
--- /dev/null
+++ b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
@@ -0,0 +1,129 @@
+import json
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Tuple
+from urllib.parse import urlencode
+
+import requests
+
+
+@dataclass
+class AutotaskZoneInfo:
+    zone_name: str
+    api_url: str
+    web_url: Optional[str] = None
+    ci: Optional[int] = None
+
+
+class AutotaskError(RuntimeError):
+    pass
+
+
+class AutotaskClient:
+    def __init__(
+        self,
+        username: str,
+        password: str,
+        api_integration_code: str,
+        environment: str = "production",
+        timeout_seconds: int = 30,
+    ) -> None:
+        self.username = username
+        self.password = password
+        self.api_integration_code = api_integration_code
+        self.environment = (environment or "production").strip().lower()
+        self.timeout_seconds = timeout_seconds
+
+        self._zone_info: Optional[AutotaskZoneInfo] = None
+
+    def _zoneinfo_base(self) -> str:
+        # Production zone lookup endpoint: webservices.autotask.net
+        # Sandbox is typically pre-release: webservices2.autotask.net
+        if self.environment == "sandbox":
+            return "https://webservices2.autotask.net/atservicesrest"
+        return "https://webservices.autotask.net/atservicesrest"
+
+    def get_zone_info(self) -> AutotaskZoneInfo:
+        if self._zone_info is not None:
+            return self._zone_info
+
+        url = f"{self._zoneinfo_base().rstrip('/')}/v1.0/zoneInformation"
+        params = {"user": self.username}
+        try:
+            resp = requests.get(url, params=params, timeout=self.timeout_seconds)
+        except Exception as exc:
+            raise AutotaskError(f"ZoneInformation request failed: {exc}") from exc
+
+        if resp.status_code >= 400:
+            raise AutotaskError(f"ZoneInformation request failed (HTTP {resp.status_code}).")
+
+        try:
+            data = resp.json()
+        except Exception as exc:
+            raise AutotaskError("ZoneInformation response is not valid JSON.") from exc
+
+        zone = AutotaskZoneInfo(
+            zone_name=str(data.get("zoneName") or ""),
+            api_url=str(data.get("url") or "").rstrip("/"),
+            web_url=(str(data.get("webUrl") or "").rstrip("/") or None),
+            ci=(int(data["ci"]) if str(data.get("ci") or "").isdigit() else None),
+        )
+
+        if not zone.api_url:
+            raise AutotaskError("ZoneInformation did not return an API URL.")
+
+        self._zone_info = zone
+        return zone
+
+    def _headers(self) -> Dict[str, str]:
+        # Autotask REST API requires the APIIntegrationcode header for API-only users.
+        return {
+            "APIIntegrationcode": self.api_integration_code,
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
+
+    def _request(self, method: str, path: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        zone = self.get_zone_info()
+        base = zone.api_url.rstrip("/")
+        url = f"{base}/v1.0/{path.lstrip('/')}"
+        try:
+            resp = requests.request(
+                method=method.upper(),
+                url=url,
+                headers=self._headers(),
+                params=params or None,
+                auth=(self.username, self.password),
+                timeout=self.timeout_seconds,
+            )
+        except Exception as exc:
+            raise AutotaskError(f"Request failed: {exc}") from exc
+
+        if resp.status_code == 401:
+            raise AutotaskError("Authentication failed (HTTP 401). Check username/password and APIIntegrationcode.")
+        if resp.status_code == 403:
+            raise AutotaskError("Access forbidden (HTTP 403). API user permissions may be insufficient.")
+        if resp.status_code == 404:
+            raise AutotaskError(f"Resource not found (HTTP 404) for path: {path}")
+        if resp.status_code >= 400:
+            raise AutotaskError(f"Autotask API error (HTTP {resp.status_code}).")
+
+        try:
+            return resp.json()
+        except Exception as exc:
+            raise AutotaskError("Autotask API response is not valid JSON.") from exc
+
+    def _query_all_first_page(self, entity_name: str) -> List[Dict[str, Any]]:
+        # Use a simple 'exist' filter on id to return the first page (up to 500 items).
+        search = {"filter": [{"op": "exist", "field": "id"}]}
+        params = {"search": json.dumps(search)}
+        data = self._request("GET", f"{entity_name}/query", params=params)
+        items = data.get("items") or []
+        if not isinstance(items, list):
+            return []
+        return items
+
+    def get_queues(self) -> List[Dict[str, Any]]:
+        return self._query_all_first_page("Queues")
+
+    def get_ticket_sources(self) -> List[Dict[str, Any]]:
+        return self._query_all_first_page("TicketSources")
diff --git a/containers/backupchecks/src/backend/app/main/routes_settings.py b/containers/backupchecks/src/backend/app/main/routes_settings.py
index 7018135..211be9a 100644
--- a/containers/backupchecks/src/backend/app/main/routes_settings.py
+++ b/containers/backupchecks/src/backend/app/main/routes_settings.py
@@ -1,5 +1,7 @@
 from .routes_shared import *  # noqa: F401,F403
 from .routes_shared import _get_database_size_bytes, _get_or_create_settings, _format_bytes, _get_free_disk_bytes, _log_admin_event
+import json
+from datetime import datetime
 
 @main_bp.route("/settings/jobs/delete-all", methods=["POST"])
 @login_required
@@ -430,6 +432,61 @@ def settings():
         if "ui_timezone" in request.form:
             settings.ui_timezone = (request.form.get("ui_timezone") or "").strip() or "Europe/Amsterdam"
 
+        # Autotask integration
+        if "autotask_enabled" in request.form:
+            settings.autotask_enabled = bool(request.form.get("autotask_enabled"))
+
+        if "autotask_environment" in request.form:
+            env_val = (request.form.get("autotask_environment") or "").strip().lower()
+            if env_val in ("sandbox", "production"):
+                settings.autotask_environment = env_val
+            else:
+                settings.autotask_environment = None
+
+        if "autotask_api_username" in request.form:
+            settings.autotask_api_username = (request.form.get("autotask_api_username") or "").strip() or None
+
+        if "autotask_api_password" in request.form:
+            pw = (request.form.get("autotask_api_password") or "").strip()
+            if pw:
+                settings.autotask_api_password = pw
+
+        if "autotask_tracking_identifier" in request.form:
+            settings.autotask_tracking_identifier = (request.form.get("autotask_tracking_identifier") or "").strip() or None
+
+        if "autotask_base_url" in request.form:
+            settings.autotask_base_url = (request.form.get("autotask_base_url") or "").strip() or None
+
+        if "autotask_default_queue_id" in request.form:
+            try:
+                settings.autotask_default_queue_id = int(request.form.get("autotask_default_queue_id") or 0) or None
+            except (ValueError, TypeError):
+                pass
+
+        if "autotask_default_ticket_source_id" in request.form:
+            try:
+                settings.autotask_default_ticket_source_id = int(request.form.get("autotask_default_ticket_source_id") or 0) or None
+            except (ValueError, TypeError):
+                pass
+
+        if "autotask_default_ticket_status" in request.form:
+            try:
+                settings.autotask_default_ticket_status = int(request.form.get("autotask_default_ticket_status") or 0) or None
+            except (ValueError, TypeError):
+                pass
+
+        if "autotask_priority_warning" in request.form:
+            try:
+                settings.autotask_priority_warning = int(request.form.get("autotask_priority_warning") or 0) or None
+            except (ValueError, TypeError):
+                pass
+
+        if "autotask_priority_error" in request.form:
+            try:
+                settings.autotask_priority_error = int(request.form.get("autotask_priority_error") or 0) or None
+            except (ValueError, TypeError):
+                pass
+
         # Daily Jobs
         if "daily_jobs_start_date" in request.form:
             daily_jobs_start_date_str = (request.form.get("daily_jobs_start_date") or "").strip()
@@ -537,6 +594,7 @@ def settings():
         free_disk_warning = free_disk_bytes < two_gb
 
     has_client_secret = bool(settings.graph_client_secret)
+    has_autotask_password = bool(getattr(settings, "autotask_api_password", None))
 
     # Common UI timezones (IANA names)
     tz_options = [
@@ -595,6 +653,23 @@ def settings():
     except Exception:
         admin_users_count = 0
 
+    # Autotask cached reference data for dropdowns
+    autotask_queues = []
+    autotask_ticket_sources = []
+    autotask_last_sync_at = getattr(settings, "autotask_reference_last_sync_at", None)
+
+    try:
+        if getattr(settings, "autotask_cached_queues_json", None):
+            autotask_queues = json.loads(settings.autotask_cached_queues_json) or []
+    except Exception:
+        autotask_queues = []
+
+    try:
+        if getattr(settings, "autotask_cached_ticket_sources_json", None):
+            autotask_ticket_sources = json.loads(settings.autotask_cached_ticket_sources_json) or []
+    except Exception:
+        autotask_ticket_sources = []
+
     return render_template(
         "main/settings.html",
         settings=settings,
@@ -602,10 +677,14 @@ def settings():
         free_disk_human=free_disk_human,
         free_disk_warning=free_disk_warning,
         has_client_secret=has_client_secret,
+        has_autotask_password=has_autotask_password,
         tz_options=tz_options,
         users=users,
         admin_users_count=admin_users_count,
         section=section,
+        autotask_queues=autotask_queues,
+        autotask_ticket_sources=autotask_ticket_sources,
+        autotask_last_sync_at=autotask_last_sync_at,
         news_admin_items=news_admin_items,
         news_admin_stats=news_admin_stats,
     )
@@ -1172,3 +1251,90 @@ def settings_folders():
         except Exception:
             pass
         return jsonify({"status": "error", "message": str(exc) or "Failed to load folders."}), 500
+
+
+@main_bp.route("/settings/autotask/test-connection", methods=["POST"])
+@login_required
+@roles_required("admin")
+def settings_autotask_test_connection():
+    settings = _get_or_create_settings()
+
+    if not settings.autotask_api_username or not settings.autotask_api_password or not settings.autotask_tracking_identifier:
+        flash("Autotask settings incomplete. Provide username, password and tracking identifier first.", "warning")
+        return redirect(url_for("main.settings", section="integrations"))
+
+    try:
+        from ..integrations.autotask.client import AutotaskClient
+        client = AutotaskClient(
+            username=settings.autotask_api_username,
+            password=settings.autotask_api_password,
+            api_integration_code=settings.autotask_tracking_identifier,
+            environment=(settings.autotask_environment or "production"),
+        )
+        zone = client.get_zone_info()
+        # Lightweight authenticated call to validate credentials
+        _ = client.get_ticket_sources()
+        flash(f"Autotask connection OK. Zone: {zone.zone_name or 'unknown'}.", "success")
+        _log_admin_event("autotask_test_connection", details={"zone": zone.zone_name, "api_url": zone.api_url})
+    except Exception as exc:
+        flash(f"Autotask connection failed: {exc}", "danger")
+        _log_admin_event("autotask_test_connection_failed", details={"error": str(exc)})
+
+    return redirect(url_for("main.settings", section="integrations"))
+
+
+@main_bp.route("/settings/autotask/refresh-reference-data", methods=["POST"])
+@login_required
+@roles_required("admin")
+def settings_autotask_refresh_reference_data():
+    settings = _get_or_create_settings()
+
+    if not settings.autotask_api_username or not settings.autotask_api_password or not settings.autotask_tracking_identifier:
+        flash("Autotask settings incomplete. Provide username, password and tracking identifier first.", "warning")
+        return redirect(url_for("main.settings", section="integrations"))
+
+    try:
+        from ..integrations.autotask.client import AutotaskClient
+        client = AutotaskClient(
+            username=settings.autotask_api_username,
+            password=settings.autotask_api_password,
+            api_integration_code=settings.autotask_tracking_identifier,
+            environment=(settings.autotask_environment or "production"),
+        )
+
+        queues = client.get_queues()
+        sources = client.get_ticket_sources()
+
+        # Store a minimal subset for dropdowns (id + name/label)
+        def _norm(items):
+            out = []
+            for it in items or []:
+                if not isinstance(it, dict):
+                    continue
+                _id = it.get("id")
+                name = it.get("name") or it.get("label") or it.get("queueName") or it.get("sourceName") or it.get("description") or ""
+                try:
+                    _id_int = int(_id)
+                except Exception:
+                    continue
+                out.append({"id": _id_int, "name": str(name)})
+            # Sort by name for stable dropdowns
+            out.sort(key=lambda x: (x.get("name") or "").lower())
+            return out
+
+        settings.autotask_cached_queues_json = json.dumps(_norm(queues))
+        settings.autotask_cached_ticket_sources_json = json.dumps(_norm(sources))
+        settings.autotask_reference_last_sync_at = datetime.utcnow()
+
+        db.session.commit()
+
+        flash(f"Autotask reference data refreshed. Queues: {len(queues)}. Ticket Sources: {len(sources)}.", "success")
+        _log_admin_event(
+            "autotask_refresh_reference_data",
+            details={"queues": len(queues or []), "ticket_sources": len(sources or [])},
+        )
+    except Exception as exc:
+        flash(f"Failed to refresh Autotask reference data: {exc}", "danger")
+        _log_admin_event("autotask_refresh_reference_data_failed", details={"error": str(exc)})
+
+    return redirect(url_for("main.settings", section="integrations"))
diff --git a/containers/backupchecks/src/backend/app/migrations.py b/containers/backupchecks/src/backend/app/migrations.py
index 334be39..eae1fd4 100644
--- a/containers/backupchecks/src/backend/app/migrations.py
+++ b/containers/backupchecks/src/backend/app/migrations.py
@@ -127,6 +127,47 @@ def migrate_system_settings_ui_timezone() -> None:
     except Exception as exc:
         print(f"[migrations] Failed to migrate system_settings.ui_timezone: {exc}")
 
+def migrate_system_settings_autotask_integration() -> None:
+    """Add Autotask integration columns to system_settings if missing."""
+
+    table = "system_settings"
+
+    columns = [
+        ("autotask_enabled", "BOOLEAN NOT NULL DEFAULT FALSE"),
+        ("autotask_environment", "VARCHAR(32) NULL"),
+        ("autotask_api_username", "VARCHAR(255) NULL"),
+        ("autotask_api_password", "VARCHAR(255) NULL"),
+        ("autotask_tracking_identifier", "VARCHAR(255) NULL"),
+        ("autotask_base_url", "VARCHAR(512) NULL"),
+        ("autotask_default_queue_id", "INTEGER NULL"),
+        ("autotask_default_ticket_source_id", "INTEGER NULL"),
+        ("autotask_default_ticket_status", "INTEGER NULL"),
+        ("autotask_priority_warning", "INTEGER NULL"),
+        ("autotask_priority_error", "INTEGER NULL"),
+        ("autotask_cached_queues_json", "TEXT NULL"),
+        ("autotask_cached_ticket_sources_json", "TEXT NULL"),
+        ("autotask_reference_last_sync_at", "TIMESTAMP NULL"),
+    ]
+
+    try:
+        engine = db.get_engine()
+    except Exception as exc:
+        print(f"[migrations] Could not get engine for system_settings autotask migration: {exc}")
+        return
+
+    try:
+        with engine.begin() as conn:
+            for column, ddl in columns:
+                if _column_exists_on_conn(conn, table, column):
+                    continue
+                conn.execute(text(f'ALTER TABLE "{table}" ADD COLUMN {column} {ddl}'))
+        print("[migrations] migrate_system_settings_autotask_integration completed.")
+    except Exception as exc:
+        print(f"[migrations] Failed to migrate system_settings autotask integration columns: {exc}")
+
+
+
+
 
 
 def migrate_mail_messages_columns() -> None:
diff --git a/containers/backupchecks/src/backend/app/models.py b/containers/backupchecks/src/backend/app/models.py
index 3d23da6..8aa2189 100644
--- a/containers/backupchecks/src/backend/app/models.py
+++ b/containers/backupchecks/src/backend/app/models.py
@@ -107,6 +107,26 @@ class SystemSettings(db.Model):
     # UI display timezone (IANA name). Used for rendering times in the web interface.
     ui_timezone = db.Column(db.String(64), nullable=False, default="Europe/Amsterdam")
 
+
+    # Autotask integration settings
+    autotask_enabled = db.Column(db.Boolean, nullable=False, default=False)
+    autotask_environment = db.Column(db.String(32), nullable=True)  # sandbox | production
+    autotask_api_username = db.Column(db.String(255), nullable=True)
+    autotask_api_password = db.Column(db.String(255), nullable=True)
+    autotask_tracking_identifier = db.Column(db.String(255), nullable=True)
+    autotask_base_url = db.Column(db.String(512), nullable=True)  # Backupchecks base URL for deep links
+
+    # Autotask defaults (IDs are leading)
+    autotask_default_queue_id = db.Column(db.Integer, nullable=True)
+    autotask_default_ticket_source_id = db.Column(db.Integer, nullable=True)
+    autotask_default_ticket_status = db.Column(db.Integer, nullable=True)
+    autotask_priority_warning = db.Column(db.Integer, nullable=True)
+    autotask_priority_error = db.Column(db.Integer, nullable=True)
+
+    # Cached reference data (for dropdowns)
+    autotask_cached_queues_json = db.Column(db.Text, nullable=True)
+    autotask_cached_ticket_sources_json = db.Column(db.Text, nullable=True)
+    autotask_reference_last_sync_at = db.Column(db.DateTime, nullable=True)
     created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
     updated_at = db.Column(
         db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False
@@ -652,4 +672,4 @@ class ReportObjectSummary(db.Model):
     report = db.relationship(
         "ReportDefinition",
         backref=db.backref("object_summaries", lazy="dynamic", cascade="all, delete-orphan"),
-    )
\ No newline at end of file
+    )
diff --git a/containers/backupchecks/src/templates/main/settings.html b/containers/backupchecks/src/templates/main/settings.html
index bdc5fbe..318ca9b 100644
--- a/containers/backupchecks/src/templates/main/settings.html
+++ b/containers/backupchecks/src/templates/main/settings.html
@@ -20,6 +20,9 @@
   <li class="nav-item">
     <a class="nav-link {% if section == 'imports' %}active{% endif %}" href="{{ url_for('main.settings', section='imports') }}">Imports</a>
   </li>
+  <li class="nav-item">
+    <a class="nav-link {% if section == 'integrations' %}active{% endif %}" href="{{ url_for('main.settings', section='integrations') }}">Integrations</a>
+  </li>
   <li class="nav-item">
     <a class="nav-link {% if section == 'maintenance' %}active{% endif %}" href="{{ url_for('main.settings', section='maintenance') }}">Maintenance</a>
   </li>

From d5fdc9a8d933d2e8e740db31f6770a6c74aab630 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Thu, 15 Jan 2026 10:21:30 +0100
Subject: [PATCH 04/63] Auto-commit local changes before build (2026-01-15
 10:21:30)

---
 .last-branch                                  |  2 +-
 .../src/backend/app/migrations.py             | 22 +++++++++++++++++++
 docs/changelog.md                             | 19 ++++++++++++++++
 3 files changed, 42 insertions(+), 1 deletion(-)

diff --git a/.last-branch b/.last-branch
index 2133928..edd3b74 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260115-01-autotask-settings
+v20260115-02-autotask-settings-migration-fix
diff --git a/containers/backupchecks/src/backend/app/migrations.py b/containers/backupchecks/src/backend/app/migrations.py
index eae1fd4..61dddae 100644
--- a/containers/backupchecks/src/backend/app/migrations.py
+++ b/containers/backupchecks/src/backend/app/migrations.py
@@ -22,6 +22,27 @@ def _is_column_nullable(table_name: str, column_name: str) -> bool:
     return False
 
 
+def _column_exists_on_conn(conn, table_name: str, column_name: str) -> bool:
+    """Return True if the given column exists using the provided connection.
+
+    This helper is useful inside engine.begin() blocks so we can check
+    column existence without creating a new inspector/connection.
+    """
+    result = conn.execute(
+        text(
+            """
+            SELECT 1
+            FROM information_schema.columns
+            WHERE table_name = :table
+              AND column_name = :column
+            LIMIT 1
+            """
+        ),
+        {"table": table_name, "column": column_name},
+    )
+    return result.first() is not None
+
+
 def migrate_add_username_to_users() -> None:
     """Ensure users.username column exists and is NOT NULL and UNIQUE.
 
@@ -820,6 +841,7 @@ def run_migrations() -> None:
     migrate_system_settings_auto_import_cutoff_date()
     migrate_system_settings_daily_jobs_start_date()
     migrate_system_settings_ui_timezone()
+    migrate_system_settings_autotask_integration()
     migrate_mail_messages_columns()
     migrate_mail_messages_parse_columns()
     migrate_mail_messages_approval_columns()
diff --git a/docs/changelog.md b/docs/changelog.md
index 0ac4238..e0197d5 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -1,3 +1,22 @@
+## v20260115-01-autotask-settings
+
+Changes:
+- Added initial Autotask integration settings structure to Backupchecks.
+- Introduced new system settings demonstrating Autotask configuration fields such as enable toggle, environment selection, credentials, tracking identifier, and Backupchecks base URL.
+- Prepared data model and persistence layer to store Autotask-related configuration.
+- Laid groundwork for future validation and integration logic without enabling ticket creation or customer mapping.
+- Ensured changes are limited to configuration foundations only, keeping Phase 1 scope intact.
+
+##
+
+v20260115-02-autotask-settings-migration-fix
+
+Changes:
+- Fixed Autotask system settings migration so it is always executed during application startup.
+- Added safe, idempotent column existence checks to prevent startup failures on re-deployments.
+- Ensured all Autotask-related system_settings columns are created before being queried.
+- Prevented aborted database transactions caused by missing columns during settings initialization.
+- Improved overall stability of the Settings page when Autotask integration is enabled.
 
 ***
 

From 1a64627a4ebe61f4fff3e0ed6c599f999d060fc9 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Thu, 15 Jan 2026 10:40:40 +0100
Subject: [PATCH 05/63] Auto-commit local changes before build (2026-01-15
 10:40:40)

---
 .last-branch                                  |   2 +-
 .../src/templates/main/settings.html          | 132 ++++++++++++++++++
 docs/changelog.md                             |  17 ++-
 3 files changed, 145 insertions(+), 6 deletions(-)

diff --git a/.last-branch b/.last-branch
index edd3b74..4be34b0 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260115-02-autotask-settings-migration-fix
+v20260115-03-autotask-settings-ui
diff --git a/containers/backupchecks/src/templates/main/settings.html b/containers/backupchecks/src/templates/main/settings.html
index 318ca9b..fe58e03 100644
--- a/containers/backupchecks/src/templates/main/settings.html
+++ b/containers/backupchecks/src/templates/main/settings.html
@@ -319,6 +319,138 @@
 {% endif %}
 
 
+{% if section == 'integrations' %}
+<form method="post" class="mb-4">
+  <div class="card mb-3">
+    <div class="card-header">Autotask</div>
+    <div class="card-body">
+      <div class="form-check form-switch mb-3">
+        <input class="form-check-input" type="checkbox" id="autotask_enabled" name="autotask_enabled" {% if settings.autotask_enabled %}checked{% endif %} />
+        <label class="form-check-label" for="autotask_enabled">Enable Autotask integration</label>
+      </div>
+
+      <div class="row g-3">
+        <div class="col-md-4">
+          <label for="autotask_environment" class="form-label">Environment</label>
+          <select class="form-select" id="autotask_environment" name="autotask_environment">
+            <option value="" {% if not settings.autotask_environment %}selected{% endif %}>Select...</option>
+            <option value="sandbox" {% if settings.autotask_environment == 'sandbox' %}selected{% endif %}>Sandbox</option>
+            <option value="production" {% if settings.autotask_environment == 'production' %}selected{% endif %}>Production</option>
+          </select>
+          <div class="form-text">Use Sandbox for testing first.</div>
+        </div>
+
+        <div class="col-md-4">
+          <label for="autotask_api_username" class="form-label">API Username</label>
+          <input type="text" class="form-control" id="autotask_api_username" name="autotask_api_username" value="{{ settings.autotask_api_username or '' }}" />
+        </div>
+
+        <div class="col-md-4">
+          <label for="autotask_api_password" class="form-label">API Password</label>
+          <input
+            type="password"
+            class="form-control"
+            id="autotask_api_password"
+            name="autotask_api_password"
+            placeholder="{% if has_autotask_password %}******** (stored){% else %}enter password{% endif %}"
+          />
+          <div class="form-text">Leave empty to keep the existing password.</div>
+        </div>
+
+        <div class="col-md-6">
+          <label for="autotask_tracking_identifier" class="form-label">Tracking Identifier (Integration Code)</label>
+          <input type="text" class="form-control" id="autotask_tracking_identifier" name="autotask_tracking_identifier" value="{{ settings.autotask_tracking_identifier or '' }}" />
+        </div>
+
+        <div class="col-md-6">
+          <label for="autotask_base_url" class="form-label">Backupchecks Base URL</label>
+          <input type="text" class="form-control" id="autotask_base_url" name="autotask_base_url" value="{{ settings.autotask_base_url or '' }}" placeholder="https://backupchecks.example.com" />
+          <div class="form-text">Required later for creating stable links to Job Details pages.</div>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <div class="card mb-3">
+    <div class="card-header">Ticket defaults</div>
+    <div class="card-body">
+      <div class="row g-3">
+        <div class="col-md-6">
+          <label for="autotask_default_queue_id" class="form-label">Default Queue</label>
+          <select class="form-select" id="autotask_default_queue_id" name="autotask_default_queue_id">
+            <option value="" {% if not settings.autotask_default_queue_id %}selected{% endif %}>Select...</option>
+            {% for q in autotask_queues %}
+              <option value="{{ q.id }}" {% if settings.autotask_default_queue_id == q.id %}selected{% endif %}>{{ q.name }}</option>
+            {% endfor %}
+          </select>
+          <div class="form-text">Requires refreshed reference data.</div>
+        </div>
+
+        <div class="col-md-6">
+          <label for="autotask_default_ticket_source_id" class="form-label">Ticket Source</label>
+          <select class="form-select" id="autotask_default_ticket_source_id" name="autotask_default_ticket_source_id">
+            <option value="" {% if not settings.autotask_default_ticket_source_id %}selected{% endif %}>Select...</option>
+            {% for s in autotask_ticket_sources %}
+              <option value="{{ s.id }}" {% if settings.autotask_default_ticket_source_id == s.id %}selected{% endif %}>{{ s.name }}</option>
+            {% endfor %}
+          </select>
+          <div class="form-text">Requires refreshed reference data.</div>
+        </div>
+
+        <div class="col-md-6">
+          <label for="autotask_priority_warning" class="form-label">Priority for Warning</label>
+          <input type="number" min="1" class="form-control" id="autotask_priority_warning" name="autotask_priority_warning" value="{{ settings.autotask_priority_warning or '' }}" />
+        </div>
+
+        <div class="col-md-6">
+          <label for="autotask_priority_error" class="form-label">Priority for Error</label>
+          <input type="number" min="1" class="form-control" id="autotask_priority_error" name="autotask_priority_error" value="{{ settings.autotask_priority_error or '' }}" />
+        </div>
+      </div>
+      <div class="form-text mt-2">Priority values are Autotask priority IDs.</div>
+    </div>
+  </div>
+
+  <div class="d-flex justify-content-end mt-3">
+    <button type="submit" class="btn btn-primary">Save settings</button>
+  </div>
+</form>
+
+<div class="card mb-4">
+  <div class="card-header">Diagnostics & reference data</div>
+  <div class="card-body">
+    <div class="row g-3 align-items-end">
+      <div class="col-md-6">
+        <div class="text-muted small">Last reference data sync</div>
+        <div class="fw-semibold">
+          {% if autotask_last_sync_at %}
+            {{ autotask_last_sync_at }}
+          {% else %}
+            never
+          {% endif %}
+        </div>
+        <div class="text-muted small mt-2">
+          Cached Queues: {{ autotask_queues|length }}<br />
+          Cached Ticket Sources: {{ autotask_ticket_sources|length }}
+        </div>
+      </div>
+      <div class="col-md-6">
+        <div class="d-flex flex-wrap gap-2 justify-content-md-end">
+          <form method="post" action="{{ url_for('main.settings_autotask_test_connection') }}">
+            <button type="submit" class="btn btn-outline-secondary">Test connection</button>
+          </form>
+          <form method="post" action="{{ url_for('main.settings_autotask_refresh_reference_data') }}">
+            <button type="submit" class="btn btn-outline-primary">Refresh reference data</button>
+          </form>
+        </div>
+        <div class="form-text mt-2 text-md-end">Refresh loads Queues and Ticket Sources from Autotask for dropdown usage.</div>
+      </div>
+    </div>
+  </div>
+</div>
+{% endif %}
+
+
 {% if section == 'maintenance' %}
 <div class="row g-3 mb-4">
   <div class="col-12 col-lg-6">
diff --git a/docs/changelog.md b/docs/changelog.md
index e0197d5..0beeca2 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -1,23 +1,30 @@
 ## v20260115-01-autotask-settings
 
-Changes:
+### Changes:
 - Added initial Autotask integration settings structure to Backupchecks.
 - Introduced new system settings demonstrating Autotask configuration fields such as enable toggle, environment selection, credentials, tracking identifier, and Backupchecks base URL.
 - Prepared data model and persistence layer to store Autotask-related configuration.
 - Laid groundwork for future validation and integration logic without enabling ticket creation or customer mapping.
 - Ensured changes are limited to configuration foundations only, keeping Phase 1 scope intact.
 
-##
+## v20260115-02-autotask-settings-migration-fix
 
-v20260115-02-autotask-settings-migration-fix
-
-Changes:
+### Changes:
 - Fixed Autotask system settings migration so it is always executed during application startup.
 - Added safe, idempotent column existence checks to prevent startup failures on re-deployments.
 - Ensured all Autotask-related system_settings columns are created before being queried.
 - Prevented aborted database transactions caused by missing columns during settings initialization.
 - Improved overall stability of the Settings page when Autotask integration is enabled.
 
+## v20260115-03-autotask-settings-ui
+
+### Changes:
+- Added visible Autotask configuration section under Settings → Integrations.
+- Implemented form fields for enabling Autotask integration, environment selection, API credentials, tracking identifier, and Backupchecks base URL.
+- Wired Autotask settings to SystemSettings for loading and saving configuration values.
+- Added Diagnostics & Reference Data section with actions for testing the Autotask connection and refreshing reference data.
+- Kept all functionality strictly within Phase 1 scope without introducing ticket or customer logic.
+
 ***
 
 ## v0.1.21

From 490ab1ae34bd834c24deb01b24c481f1fa3d26ff Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Thu, 15 Jan 2026 11:10:13 +0100
Subject: [PATCH 06/63] Auto-commit local changes before build (2026-01-15
 11:10:13)

---
 .last-branch                                  |  2 +-
 .../app/integrations/autotask/client.py       | 91 ++++++++++++++++---
 .../src/backend/app/main/routes_settings.py   | 56 ++++++++++--
 .../src/backend/app/migrations.py             |  1 +
 .../backupchecks/src/backend/app/models.py    |  1 +
 .../src/templates/main/settings.html          | 23 ++++-
 docs/changelog.md                             | 12 +++
 7 files changed, 161 insertions(+), 25 deletions(-)

diff --git a/.last-branch b/.last-branch
index 4be34b0..782eaef 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260115-03-autotask-settings-ui
+v20260115-04-autotask-reference-data-fix
diff --git a/containers/backupchecks/src/backend/app/integrations/autotask/client.py b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
index 9eaa036..95eb90c 100644
--- a/containers/backupchecks/src/backend/app/integrations/autotask/client.py
+++ b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
@@ -1,7 +1,6 @@
 import json
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Tuple
-from urllib.parse import urlencode
+from typing import Any, Dict, List, Optional
 
 import requests
 
@@ -82,7 +81,7 @@ class AutotaskClient:
             "Accept": "application/json",
         }
 
-    def _request(self, method: str, path: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+    def _request(self, method: str, path: str, params: Optional[Dict[str, Any]] = None) -> Any:
         zone = self.get_zone_info()
         base = zone.api_url.rstrip("/")
         url = f"{base}/v1.0/{path.lstrip('/')}"
@@ -112,18 +111,84 @@ class AutotaskClient:
         except Exception as exc:
             raise AutotaskError("Autotask API response is not valid JSON.") from exc
 
-    def _query_all_first_page(self, entity_name: str) -> List[Dict[str, Any]]:
-        # Use a simple 'exist' filter on id to return the first page (up to 500 items).
-        search = {"filter": [{"op": "exist", "field": "id"}]}
-        params = {"search": json.dumps(search)}
-        data = self._request("GET", f"{entity_name}/query", params=params)
-        items = data.get("items") or []
-        if not isinstance(items, list):
+    def _as_items_list(self, payload: Any) -> List[Dict[str, Any]]:
+        """Normalize common Autotask REST payload shapes to a list of dicts."""
+        if payload is None:
             return []
-        return items
+
+        if isinstance(payload, list):
+            return [x for x in payload if isinstance(x, dict)]
+
+        if isinstance(payload, dict):
+            items = payload.get("items")
+            if isinstance(items, list):
+                return [x for x in items if isinstance(x, dict)]
+
+            # Some endpoints may return a single object.
+            if "id" in payload:
+                return [payload]
+
+        return []
+
+    def _get_collection(self, resource_name: str) -> List[Dict[str, Any]]:
+        """Fetch a reference collection via GET /<resource>.
+
+        Note: Not all Autotask entities support /query. Reference data like Queues and
+        TicketSources is typically retrieved via a simple collection GET.
+        """
+        data = self._request("GET", resource_name)
+        return self._as_items_list(data)
+
+    def _get_entity_fields(self, entity_name: str) -> List[Dict[str, Any]]:
+        data = self._request("GET", f"{entity_name}/entityInformation/fields")
+        return self._as_items_list(data)
+
+    def _call_picklist_values(self, picklist_values_path: str) -> List[Dict[str, Any]]:
+        # picklistValues path can be returned as a full URL or as a relative path.
+        path = (picklist_values_path or "").strip()
+        if not path:
+            return []
+
+        # If a full URL is returned, strip everything up to /v1.0/
+        if "/v1.0/" in path:
+            path = path.split("/v1.0/", 1)[1]
+        # If it includes the base API URL without /v1.0, strip to resource path.
+        if "/atservicesrest/" in path and "/v1.0/" not in picklist_values_path:
+            # Fallback: attempt to strip after atservicesrest/
+            path = path.split("/atservicesrest/", 1)[1]
+            if path.startswith("v1.0/"):
+                path = path.split("v1.0/", 1)[1]
+
+        data = self._request("GET", path)
+        return self._as_items_list(data)
 
     def get_queues(self) -> List[Dict[str, Any]]:
-        return self._query_all_first_page("Queues")
+        return self._get_collection("Queues")
 
     def get_ticket_sources(self) -> List[Dict[str, Any]]:
-        return self._query_all_first_page("TicketSources")
+        return self._get_collection("TicketSources")
+
+    def get_ticket_priorities(self) -> List[Dict[str, Any]]:
+        """Return Ticket Priority picklist values.
+
+        We intentionally retrieve this from entity metadata to prevent hardcoded priority IDs.
+        """
+        fields = self._get_entity_fields("Tickets")
+        priority_field: Optional[Dict[str, Any]] = None
+        for f in fields:
+            name = str(f.get("name") or "").strip().lower()
+            if name == "priority":
+                priority_field = f
+                break
+
+        if not priority_field:
+            raise AutotaskError("Unable to locate Tickets.priority field metadata for picklist retrieval.")
+
+        if not bool(priority_field.get("isPickList")):
+            raise AutotaskError("Tickets.priority is not marked as a picklist in Autotask metadata.")
+
+        picklist_path = priority_field.get("picklistValues")
+        if not isinstance(picklist_path, str) or not picklist_path.strip():
+            raise AutotaskError("Tickets.priority metadata did not include a picklistValues endpoint.")
+
+        return self._call_picklist_values(picklist_path)
diff --git a/containers/backupchecks/src/backend/app/main/routes_settings.py b/containers/backupchecks/src/backend/app/main/routes_settings.py
index 211be9a..1127187 100644
--- a/containers/backupchecks/src/backend/app/main/routes_settings.py
+++ b/containers/backupchecks/src/backend/app/main/routes_settings.py
@@ -656,6 +656,7 @@ def settings():
     # Autotask cached reference data for dropdowns
     autotask_queues = []
     autotask_ticket_sources = []
+    autotask_priorities = []
     autotask_last_sync_at = getattr(settings, "autotask_reference_last_sync_at", None)
 
     try:
@@ -670,6 +671,12 @@ def settings():
     except Exception:
         autotask_ticket_sources = []
 
+    try:
+        if getattr(settings, "autotask_cached_priorities_json", None):
+            autotask_priorities = json.loads(settings.autotask_cached_priorities_json) or []
+    except Exception:
+        autotask_priorities = []
+
     return render_template(
         "main/settings.html",
         settings=settings,
@@ -684,6 +691,7 @@ def settings():
         section=section,
         autotask_queues=autotask_queues,
         autotask_ticket_sources=autotask_ticket_sources,
+        autotask_priorities=autotask_priorities,
         autotask_last_sync_at=autotask_last_sync_at,
         news_admin_items=news_admin_items,
         news_admin_stats=news_admin_stats,
@@ -1272,13 +1280,22 @@ def settings_autotask_test_connection():
             environment=(settings.autotask_environment or "production"),
         )
         zone = client.get_zone_info()
-        # Lightweight authenticated call to validate credentials
+        # Lightweight authenticated calls to validate credentials and basic API access
+        _ = client.get_queues()
         _ = client.get_ticket_sources()
         flash(f"Autotask connection OK. Zone: {zone.zone_name or 'unknown'}.", "success")
-        _log_admin_event("autotask_test_connection", details={"zone": zone.zone_name, "api_url": zone.api_url})
+        _log_admin_event(
+            "autotask_test_connection",
+            "Autotask test connection succeeded.",
+            details=json.dumps({"zone": zone.zone_name, "api_url": zone.api_url}),
+        )
     except Exception as exc:
         flash(f"Autotask connection failed: {exc}", "danger")
-        _log_admin_event("autotask_test_connection_failed", details={"error": str(exc)})
+        _log_admin_event(
+            "autotask_test_connection_failed",
+            "Autotask test connection failed.",
+            details=json.dumps({"error": str(exc)}),
+        )
 
     return redirect(url_for("main.settings", section="integrations"))
 
@@ -1304,6 +1321,7 @@ def settings_autotask_refresh_reference_data():
 
         queues = client.get_queues()
         sources = client.get_ticket_sources()
+        priorities = client.get_ticket_priorities()
 
         # Store a minimal subset for dropdowns (id + name/label)
         def _norm(items):
@@ -1324,17 +1342,43 @@ def settings_autotask_refresh_reference_data():
 
         settings.autotask_cached_queues_json = json.dumps(_norm(queues))
         settings.autotask_cached_ticket_sources_json = json.dumps(_norm(sources))
+
+        # Priorities are returned as picklist values (value/label)
+        pr_out = []
+        for it in priorities or []:
+            if not isinstance(it, dict):
+                continue
+            if it.get("isActive") is False:
+                continue
+            val = it.get("value")
+            label = it.get("label") or it.get("name") or ""
+            try:
+                val_int = int(val)
+            except Exception:
+                continue
+            pr_out.append({"id": val_int, "name": str(label)})
+        pr_out.sort(key=lambda x: (x.get("name") or "").lower())
+
+        settings.autotask_cached_priorities_json = json.dumps(pr_out)
         settings.autotask_reference_last_sync_at = datetime.utcnow()
 
         db.session.commit()
 
-        flash(f"Autotask reference data refreshed. Queues: {len(queues)}. Ticket Sources: {len(sources)}.", "success")
+        flash(
+            f"Autotask reference data refreshed. Queues: {len(queues)}. Ticket Sources: {len(sources)}. Priorities: {len(pr_out)}.",
+            "success",
+        )
         _log_admin_event(
             "autotask_refresh_reference_data",
-            details={"queues": len(queues or []), "ticket_sources": len(sources or [])},
+            "Autotask reference data refreshed.",
+            details=json.dumps({"queues": len(queues or []), "ticket_sources": len(sources or []), "priorities": len(pr_out)}),
         )
     except Exception as exc:
         flash(f"Failed to refresh Autotask reference data: {exc}", "danger")
-        _log_admin_event("autotask_refresh_reference_data_failed", details={"error": str(exc)})
+        _log_admin_event(
+            "autotask_refresh_reference_data_failed",
+            "Autotask reference data refresh failed.",
+            details=json.dumps({"error": str(exc)}),
+        )
 
     return redirect(url_for("main.settings", section="integrations"))
diff --git a/containers/backupchecks/src/backend/app/migrations.py b/containers/backupchecks/src/backend/app/migrations.py
index 61dddae..71a697e 100644
--- a/containers/backupchecks/src/backend/app/migrations.py
+++ b/containers/backupchecks/src/backend/app/migrations.py
@@ -167,6 +167,7 @@ def migrate_system_settings_autotask_integration() -> None:
         ("autotask_priority_error", "INTEGER NULL"),
         ("autotask_cached_queues_json", "TEXT NULL"),
         ("autotask_cached_ticket_sources_json", "TEXT NULL"),
+        ("autotask_cached_priorities_json", "TEXT NULL"),
         ("autotask_reference_last_sync_at", "TIMESTAMP NULL"),
     ]
 
diff --git a/containers/backupchecks/src/backend/app/models.py b/containers/backupchecks/src/backend/app/models.py
index 8aa2189..3aec257 100644
--- a/containers/backupchecks/src/backend/app/models.py
+++ b/containers/backupchecks/src/backend/app/models.py
@@ -126,6 +126,7 @@ class SystemSettings(db.Model):
     # Cached reference data (for dropdowns)
     autotask_cached_queues_json = db.Column(db.Text, nullable=True)
     autotask_cached_ticket_sources_json = db.Column(db.Text, nullable=True)
+    autotask_cached_priorities_json = db.Column(db.Text, nullable=True)
     autotask_reference_last_sync_at = db.Column(db.DateTime, nullable=True)
     created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
     updated_at = db.Column(
diff --git a/containers/backupchecks/src/templates/main/settings.html b/containers/backupchecks/src/templates/main/settings.html
index fe58e03..6c52acb 100644
--- a/containers/backupchecks/src/templates/main/settings.html
+++ b/containers/backupchecks/src/templates/main/settings.html
@@ -399,15 +399,27 @@
 
         <div class="col-md-6">
           <label for="autotask_priority_warning" class="form-label">Priority for Warning</label>
-          <input type="number" min="1" class="form-control" id="autotask_priority_warning" name="autotask_priority_warning" value="{{ settings.autotask_priority_warning or '' }}" />
+          <select class="form-select" id="autotask_priority_warning" name="autotask_priority_warning">
+            <option value="" {% if not settings.autotask_priority_warning %}selected{% endif %}>Select...</option>
+            {% for p in autotask_priorities %}
+              <option value="{{ p.id }}" {% if settings.autotask_priority_warning == p.id %}selected{% endif %}>{{ p.name }}</option>
+            {% endfor %}
+          </select>
+          <div class="form-text">Requires refreshed reference data.</div>
         </div>
 
         <div class="col-md-6">
           <label for="autotask_priority_error" class="form-label">Priority for Error</label>
-          <input type="number" min="1" class="form-control" id="autotask_priority_error" name="autotask_priority_error" value="{{ settings.autotask_priority_error or '' }}" />
+          <select class="form-select" id="autotask_priority_error" name="autotask_priority_error">
+            <option value="" {% if not settings.autotask_priority_error %}selected{% endif %}>Select...</option>
+            {% for p in autotask_priorities %}
+              <option value="{{ p.id }}" {% if settings.autotask_priority_error == p.id %}selected{% endif %}>{{ p.name }}</option>
+            {% endfor %}
+          </select>
+          <div class="form-text">Requires refreshed reference data.</div>
         </div>
       </div>
-      <div class="form-text mt-2">Priority values are Autotask priority IDs.</div>
+      <div class="form-text mt-2">Priorities are loaded from Autotask to avoid manual ID mistakes.</div>
     </div>
   </div>
 
@@ -431,7 +443,8 @@
         </div>
         <div class="text-muted small mt-2">
           Cached Queues: {{ autotask_queues|length }}<br />
-          Cached Ticket Sources: {{ autotask_ticket_sources|length }}
+          Cached Ticket Sources: {{ autotask_ticket_sources|length }}<br />
+          Cached Priorities: {{ autotask_priorities|length }}
         </div>
       </div>
       <div class="col-md-6">
@@ -443,7 +456,7 @@
             <button type="submit" class="btn btn-outline-primary">Refresh reference data</button>
           </form>
         </div>
-        <div class="form-text mt-2 text-md-end">Refresh loads Queues and Ticket Sources from Autotask for dropdown usage.</div>
+        <div class="form-text mt-2 text-md-end">Refresh loads Queues, Ticket Sources, and Priorities from Autotask for dropdown usage.</div>
       </div>
     </div>
   </div>
diff --git a/docs/changelog.md b/docs/changelog.md
index 0beeca2..93888d6 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -25,6 +25,18 @@
 - Added Diagnostics & Reference Data section with actions for testing the Autotask connection and refreshing reference data.
 - Kept all functionality strictly within Phase 1 scope without introducing ticket or customer logic.
 
+## v20260115-04-autotask-reference-data-fix
+
+### Changes:
+- Fixed Autotask API client to use correct endpoints for reference data instead of invalid `/query` routes.
+- Implemented proper retrieval of Autotask Queues and Ticket Sources via collection endpoints.
+- Added dynamic retrieval of Autotask Priorities using ticket entity metadata and picklist values.
+- Cached queues, ticket sources, and priorities in system settings for safe reuse in the UI.
+- Updated Autotask settings UI to use dropdowns backed by live Autotask reference data.
+- Improved “Test connection” to validate authentication and reference data access reliably.
+- Fixed admin event logging to prevent secondary exceptions during error handling.
+
+
 ***
 
 ## v0.1.21

From 83d487a2066c1f708d022072949f209343de5a16 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Thu, 15 Jan 2026 11:52:52 +0100
Subject: [PATCH 07/63] Auto-commit local changes before build (2026-01-15
 11:52:52)

---
 .last-branch                                  |  2 +-
 .../app/integrations/autotask/client.py       | 37 ++++++++++++++++++-
 .../src/backend/app/main/routes_settings.py   | 14 ++++++-
 docs/changelog.md                             |  9 +++++
 4 files changed, 58 insertions(+), 4 deletions(-)

diff --git a/.last-branch b/.last-branch
index 782eaef..f8987a1 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260115-04-autotask-reference-data-fix
+v20260115-05-autotask-queues-picklist-fix
diff --git a/containers/backupchecks/src/backend/app/integrations/autotask/client.py b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
index 95eb90c..b82983c 100644
--- a/containers/backupchecks/src/backend/app/integrations/autotask/client.py
+++ b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
@@ -163,10 +163,43 @@ class AutotaskClient:
         return self._as_items_list(data)
 
     def get_queues(self) -> List[Dict[str, Any]]:
-        return self._get_collection("Queues")
+        """Return Ticket Queue picklist values.
+
+        Autotask does not expose a universal top-level Queues entity in all tenants.
+        The reliable source is the Tickets.queueID picklist metadata.
+        """
+        return self._get_ticket_picklist_values(field_names=["queueid", "queue"])
 
     def get_ticket_sources(self) -> List[Dict[str, Any]]:
-        return self._get_collection("TicketSources")
+        """Return Ticket Source picklist values.
+
+        Similar to queues, Ticket Source values are best retrieved via the
+        Tickets.source picklist metadata to avoid relying on optional entities.
+        """
+        return self._get_ticket_picklist_values(field_names=["source", "sourceid"])
+
+    def _get_ticket_picklist_values(self, field_names: List[str]) -> List[Dict[str, Any]]:
+        fields = self._get_entity_fields("Tickets")
+        wanted = {n.strip().lower() for n in (field_names or []) if str(n).strip()}
+
+        field: Optional[Dict[str, Any]] = None
+        for f in fields:
+            name = str(f.get("name") or "").strip().lower()
+            if name in wanted:
+                field = f
+                break
+
+        if not field:
+            raise AutotaskError(f"Unable to locate Tickets field metadata for picklist retrieval: {sorted(wanted)}")
+
+        if not bool(field.get("isPickList")):
+            raise AutotaskError(f"Tickets.{field.get('name')} is not marked as a picklist in Autotask metadata.")
+
+        picklist_path = field.get("picklistValues")
+        if not isinstance(picklist_path, str) or not picklist_path.strip():
+            raise AutotaskError(f"Tickets.{field.get('name')} metadata did not include a picklistValues endpoint.")
+
+        return self._call_picklist_values(picklist_path)
 
     def get_ticket_priorities(self) -> List[Dict[str, Any]]:
         """Return Ticket Priority picklist values.
diff --git a/containers/backupchecks/src/backend/app/main/routes_settings.py b/containers/backupchecks/src/backend/app/main/routes_settings.py
index 1127187..5897121 100644
--- a/containers/backupchecks/src/backend/app/main/routes_settings.py
+++ b/containers/backupchecks/src/backend/app/main/routes_settings.py
@@ -1324,13 +1324,25 @@ def settings_autotask_refresh_reference_data():
         priorities = client.get_ticket_priorities()
 
         # Store a minimal subset for dropdowns (id + name/label)
+        # Note: Some "reference" values are exposed as picklists (value/label)
+        # instead of entity collections (id/name). We normalize both shapes.
         def _norm(items):
             out = []
             for it in items or []:
                 if not isinstance(it, dict):
                     continue
                 _id = it.get("id")
-                name = it.get("name") or it.get("label") or it.get("queueName") or it.get("sourceName") or it.get("description") or ""
+                if _id is None:
+                    _id = it.get("value")
+
+                name = (
+                    it.get("name")
+                    or it.get("label")
+                    or it.get("queueName")
+                    or it.get("sourceName")
+                    or it.get("description")
+                    or ""
+                )
                 try:
                     _id_int = int(_id)
                 except Exception:
diff --git a/docs/changelog.md b/docs/changelog.md
index 93888d6..161d863 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -36,6 +36,15 @@
 - Improved “Test connection” to validate authentication and reference data access reliably.
 - Fixed admin event logging to prevent secondary exceptions during error handling.
 
+## v20260115-05-autotask-queues-picklist-fix
+
+Changes:
+- Reworked Autotask reference data retrieval to use Ticket entity picklists instead of non-existent top-level resources.
+- Retrieved Queues via the Tickets.queueID picklist to ensure compatibility with all Autotask tenants.
+- Retrieved Ticket Sources via the Tickets.source picklist instead of a direct collection endpoint.
+- Kept Priority retrieval fully dynamic using the Tickets.priority picklist.
+- Normalized picklist values so IDs and display labels are handled consistently in settings dropdowns.
+- Fixed Autotask connection test to rely on picklist availability, preventing false 404 errors.
 
 ***
 

From 1a2ca59d16b69f5de59a0dbd01f9bed201a8f2df Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Thu, 15 Jan 2026 12:31:08 +0100
Subject: [PATCH 08/63] Auto-commit local changes before build (2026-01-15
 12:31:08)

---
 .last-branch                                  |  2 +-
 .../app/integrations/autotask/client.py       | 89 ++++++++++++++-----
 docs/changelog.md                             |  9 ++
 3 files changed, 76 insertions(+), 24 deletions(-)

diff --git a/.last-branch b/.last-branch
index f8987a1..83d7747 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260115-05-autotask-queues-picklist-fix
+v20260115-06-autotask-auth-fallback
diff --git a/containers/backupchecks/src/backend/app/integrations/autotask/client.py b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
index b82983c..e45f4f5 100644
--- a/containers/backupchecks/src/backend/app/integrations/autotask/client.py
+++ b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
@@ -33,32 +33,51 @@ class AutotaskClient:
         self.timeout_seconds = timeout_seconds
 
         self._zone_info: Optional[AutotaskZoneInfo] = None
+        self._zoneinfo_base_used: Optional[str] = None
 
-    def _zoneinfo_base(self) -> str:
-        # Production zone lookup endpoint: webservices.autotask.net
-        # Sandbox is typically pre-release: webservices2.autotask.net
+    def _zoneinfo_bases(self) -> List[str]:
+        """Return a list of zoneInformation base URLs to try.
+
+        Autotask tenants can behave differently for Sandbox vs Production.
+        To keep connection testing reliable, we try the expected base first
+        and fall back to the alternative if needed.
+        """
+        prod = "https://webservices.autotask.net/atservicesrest"
+        sb = "https://webservices2.autotask.net/atservicesrest"
         if self.environment == "sandbox":
-            return "https://webservices2.autotask.net/atservicesrest"
-        return "https://webservices.autotask.net/atservicesrest"
+            return [sb, prod]
+        return [prod, sb]
 
     def get_zone_info(self) -> AutotaskZoneInfo:
         if self._zone_info is not None:
             return self._zone_info
 
-        url = f"{self._zoneinfo_base().rstrip('/')}/v1.0/zoneInformation"
-        params = {"user": self.username}
-        try:
-            resp = requests.get(url, params=params, timeout=self.timeout_seconds)
-        except Exception as exc:
-            raise AutotaskError(f"ZoneInformation request failed: {exc}") from exc
+        last_error: Optional[str] = None
+        data: Optional[Dict[str, Any]] = None
+        for base in self._zoneinfo_bases():
+            url = f"{base.rstrip('/')}/v1.0/zoneInformation"
+            params = {"user": self.username}
+            try:
+                resp = requests.get(url, params=params, timeout=self.timeout_seconds)
+            except Exception as exc:
+                last_error = f"ZoneInformation request failed for {base}: {exc}"
+                continue
 
-        if resp.status_code >= 400:
-            raise AutotaskError(f"ZoneInformation request failed (HTTP {resp.status_code}).")
+            if resp.status_code >= 400:
+                last_error = f"ZoneInformation request failed for {base} (HTTP {resp.status_code})."
+                continue
 
-        try:
-            data = resp.json()
-        except Exception as exc:
-            raise AutotaskError("ZoneInformation response is not valid JSON.") from exc
+            try:
+                data = resp.json()
+            except Exception:
+                last_error = f"ZoneInformation response from {base} is not valid JSON."
+                continue
+
+            self._zoneinfo_base_used = base
+            break
+
+        if data is None:
+            raise AutotaskError(last_error or "ZoneInformation request failed.")
 
         zone = AutotaskZoneInfo(
             zone_name=str(data.get("zoneName") or ""),
@@ -74,8 +93,11 @@ class AutotaskClient:
         return zone
 
     def _headers(self) -> Dict[str, str]:
-        # Autotask REST API requires the APIIntegrationcode header for API-only users.
+        # Autotask REST API requires the ApiIntegrationCode header.
+        # Some tenants/proxies appear picky despite headers being case-insensitive,
+        # so we include both common casings for maximum compatibility.
         return {
+            "ApiIntegrationCode": self.api_integration_code,
             "APIIntegrationcode": self.api_integration_code,
             "Content-Type": "application/json",
             "Accept": "application/json",
@@ -85,20 +107,41 @@ class AutotaskClient:
         zone = self.get_zone_info()
         base = zone.api_url.rstrip("/")
         url = f"{base}/v1.0/{path.lstrip('/')}"
-        try:
-            resp = requests.request(
+        headers = self._headers()
+
+        def do_request(use_basic_auth: bool, extra_headers: Optional[Dict[str, str]] = None):
+            h = dict(headers)
+            if extra_headers:
+                h.update(extra_headers)
+            return requests.request(
                 method=method.upper(),
                 url=url,
-                headers=self._headers(),
+                headers=h,
                 params=params or None,
-                auth=(self.username, self.password),
+                auth=(self.username, self.password) if use_basic_auth else None,
                 timeout=self.timeout_seconds,
             )
+
+        try:
+            # Primary auth method: HTTP Basic (username + API secret)
+            resp = do_request(use_basic_auth=True)
+
+            # Compatibility fallback: some environments accept credentials only via headers.
+            if resp.status_code == 401:
+                resp = do_request(
+                    use_basic_auth=False,
+                    extra_headers={"UserName": self.username, "Secret": self.password},
+                )
         except Exception as exc:
             raise AutotaskError(f"Request failed: {exc}") from exc
 
         if resp.status_code == 401:
-            raise AutotaskError("Authentication failed (HTTP 401). Check username/password and APIIntegrationcode.")
+            zi_base = self._zoneinfo_base_used or "unknown"
+            raise AutotaskError(
+                "Authentication failed (HTTP 401). "
+                "Verify API Username, API Secret, and ApiIntegrationCode. "
+                f"Environment={self.environment}, ZoneInfoBase={zi_base}, ZoneApiUrl={zone.api_url}."
+            )
         if resp.status_code == 403:
             raise AutotaskError("Access forbidden (HTTP 403). API user permissions may be insufficient.")
         if resp.status_code == 404:
diff --git a/docs/changelog.md b/docs/changelog.md
index 161d863..cd4b606 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -46,6 +46,15 @@ Changes:
 - Normalized picklist values so IDs and display labels are handled consistently in settings dropdowns.
 - Fixed Autotask connection test to rely on picklist availability, preventing false 404 errors.
 
+## v20260115-06-autotask-auth-fallback
+
+### Changes:
+- Improved Autotask authentication handling to support sandbox-specific behavior.
+- Implemented automatic fallback authentication flow when initial Basic Auth returns HTTP 401.
+- Added support for header-based authentication using UserName and Secret headers alongside the Integration Code.
+- Extended authentication error diagnostics to include selected environment and resolved Autotask zone information.
+- Increased reliability of Autotask connection testing across different tenants and sandbox configurations.
+
 ***
 
 ## v0.1.21

From 981d65c27450881bcb09cc910b52d6113cbb95bf Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Thu, 15 Jan 2026 12:44:01 +0100
Subject: [PATCH 09/63] Auto-commit local changes before build (2026-01-15
 12:44:01)

---
 .last-branch                                  |  2 +-
 .../app/integrations/autotask/client.py       | 55 ++++++++++++++++++-
 docs/changelog.md                             |  9 +++
 3 files changed, 63 insertions(+), 3 deletions(-)

diff --git a/.last-branch b/.last-branch
index 83d7747..36c68d6 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260115-06-autotask-auth-fallback
+v20260115-07-autotask-picklist-field-detect
diff --git a/containers/backupchecks/src/backend/app/integrations/autotask/client.py b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
index e45f4f5..0f39cfd 100644
--- a/containers/backupchecks/src/backend/app/integrations/autotask/client.py
+++ b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
@@ -222,18 +222,50 @@ class AutotaskClient:
         return self._get_ticket_picklist_values(field_names=["source", "sourceid"])
 
     def _get_ticket_picklist_values(self, field_names: List[str]) -> List[Dict[str, Any]]:
+        """Retrieve picklist values for a Tickets field.
+
+        Autotask field metadata can vary between tenants/environments.
+        We first try exact name matches, then fall back to a contains-match
+        on the metadata field name/label for picklist fields.
+        """
+
         fields = self._get_entity_fields("Tickets")
         wanted = {n.strip().lower() for n in (field_names or []) if str(n).strip()}
 
+        def _field_label(f: Dict[str, Any]) -> str:
+            # Autotask metadata commonly provides either "label" or "displayName".
+            return str(f.get("label") or f.get("displayName") or "").strip().lower()
+
         field: Optional[Dict[str, Any]] = None
+
+        # 1) Exact name match
         for f in fields:
             name = str(f.get("name") or "").strip().lower()
             if name in wanted:
                 field = f
                 break
 
+        # 2) Fallback: contains match for picklists (handles QueueID vs TicketQueueID etc.)
+        if field is None and wanted:
+            candidates: List[Dict[str, Any]] = []
+            for f in fields:
+                if not bool(f.get("isPickList")):
+                    continue
+                name = str(f.get("name") or "").strip().lower()
+                label = _field_label(f)
+                if any(w in name for w in wanted) or any(w in label for w in wanted):
+                    candidates.append(f)
+
+            if candidates:
+                # Prefer the most specific/shortest name match to avoid overly broad matches.
+                candidates.sort(key=lambda x: len(str(x.get("name") or "")))
+                field = candidates[0]
+
         if not field:
-            raise AutotaskError(f"Unable to locate Tickets field metadata for picklist retrieval: {sorted(wanted)}")
+            raise AutotaskError(
+                "Unable to locate Tickets field metadata for picklist retrieval: "
+                f"{sorted(wanted)}"
+            )
 
         if not bool(field.get("isPickList")):
             raise AutotaskError(f"Tickets.{field.get('name')} is not marked as a picklist in Autotask metadata.")
@@ -251,14 +283,33 @@ class AutotaskClient:
         """
         fields = self._get_entity_fields("Tickets")
         priority_field: Optional[Dict[str, Any]] = None
+
+        def _field_label(f: Dict[str, Any]) -> str:
+            return str(f.get("label") or f.get("displayName") or "").strip().lower()
+
+        # Exact match first
         for f in fields:
             name = str(f.get("name") or "").strip().lower()
             if name == "priority":
                 priority_field = f
                 break
 
+        # Fallback: contains match (handles variations like TicketPriority)
+        if priority_field is None:
+            candidates: List[Dict[str, Any]] = []
+            for f in fields:
+                if not bool(f.get("isPickList")):
+                    continue
+                name = str(f.get("name") or "").strip().lower()
+                label = _field_label(f)
+                if "priority" in name or "priority" in label:
+                    candidates.append(f)
+            if candidates:
+                candidates.sort(key=lambda x: len(str(x.get("name") or "")))
+                priority_field = candidates[0]
+
         if not priority_field:
-            raise AutotaskError("Unable to locate Tickets.priority field metadata for picklist retrieval.")
+            raise AutotaskError("Unable to locate a Tickets priority picklist field in Autotask metadata.")
 
         if not bool(priority_field.get("isPickList")):
             raise AutotaskError("Tickets.priority is not marked as a picklist in Autotask metadata.")
diff --git a/docs/changelog.md b/docs/changelog.md
index cd4b606..e8a1911 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -55,6 +55,15 @@ Changes:
 - Extended authentication error diagnostics to include selected environment and resolved Autotask zone information.
 - Increased reliability of Autotask connection testing across different tenants and sandbox configurations.
 
+## v20260115-07-autotask-picklist-field-detect
+
+### Changes:
+- Improved detection of Autotask Ticket entity picklist fields to handle tenant-specific field naming.
+- Added fallback matching logic based on field name and display label for picklist fields.
+- Fixed queue picklist resolution when fields are not named exactly `queue` or `queueid`.
+- Applied the same robust detection logic to ticket priority picklist retrieval.
+- Prevented connection test failures caused by missing or differently named metadata fields.
+
 ***
 
 ## v0.1.21

From 5b9b6f4c38b931720ace89b1045fbab259e7e42d Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Thu, 15 Jan 2026 13:45:53 +0100
Subject: [PATCH 10/63] Auto-commit local changes before build (2026-01-15
 13:45:53)

---
 .last-branch                                  |  2 +-
 .../app/integrations/autotask/client.py       | 27 +++++++++++++------
 docs/changelog.md                             | 10 +++++++
 3 files changed, 30 insertions(+), 9 deletions(-)

diff --git a/.last-branch b/.last-branch
index 36c68d6..08b1612 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260115-07-autotask-picklist-field-detect
+v20260115-08-autotask-entityinfo-fields-shape-fix
diff --git a/containers/backupchecks/src/backend/app/integrations/autotask/client.py b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
index 0f39cfd..7f86fb6 100644
--- a/containers/backupchecks/src/backend/app/integrations/autotask/client.py
+++ b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
@@ -167,6 +167,10 @@ class AutotaskClient:
             if isinstance(items, list):
                 return [x for x in items if isinstance(x, dict)]
 
+            fields = payload.get("fields")
+            if isinstance(fields, list):
+                return [x for x in fields if isinstance(x, dict)]
+
             # Some endpoints may return a single object.
             if "id" in payload:
                 return [payload]
@@ -270,11 +274,15 @@ class AutotaskClient:
         if not bool(field.get("isPickList")):
             raise AutotaskError(f"Tickets.{field.get('name')} is not marked as a picklist in Autotask metadata.")
 
-        picklist_path = field.get("picklistValues")
-        if not isinstance(picklist_path, str) or not picklist_path.strip():
-            raise AutotaskError(f"Tickets.{field.get('name')} metadata did not include a picklistValues endpoint.")
+        picklist_values = field.get("picklistValues")
+        # Autotask may return picklist values inline (as a list) or as a URL/path.
+        if isinstance(picklist_values, list):
+            return [x for x in picklist_values if isinstance(x, dict)]
 
-        return self._call_picklist_values(picklist_path)
+        if not isinstance(picklist_values, str) or not picklist_values.strip():
+            raise AutotaskError(f"Tickets.{field.get('name')} metadata did not include picklist values.")
+
+        return self._call_picklist_values(picklist_values)
 
     def get_ticket_priorities(self) -> List[Dict[str, Any]]:
         """Return Ticket Priority picklist values.
@@ -314,8 +322,11 @@ class AutotaskClient:
         if not bool(priority_field.get("isPickList")):
             raise AutotaskError("Tickets.priority is not marked as a picklist in Autotask metadata.")
 
-        picklist_path = priority_field.get("picklistValues")
-        if not isinstance(picklist_path, str) or not picklist_path.strip():
-            raise AutotaskError("Tickets.priority metadata did not include a picklistValues endpoint.")
+        picklist_values = priority_field.get("picklistValues")
+        if isinstance(picklist_values, list):
+            return [x for x in picklist_values if isinstance(x, dict)]
 
-        return self._call_picklist_values(picklist_path)
+        if not isinstance(picklist_values, str) or not picklist_values.strip():
+            raise AutotaskError("Tickets.priority metadata did not include picklist values.")
+
+        return self._call_picklist_values(picklist_values)
diff --git a/docs/changelog.md b/docs/changelog.md
index e8a1911..6955786 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -64,6 +64,16 @@ Changes:
 - Applied the same robust detection logic to ticket priority picklist retrieval.
 - Prevented connection test failures caused by missing or differently named metadata fields.
 
+## v20260115-08-autotask-entityinfo-fields-shape-fix
+
+### Changes:
+- Fixed parsing of Autotask entityInformation responses to correctly read field metadata from the `fields` attribute.
+- Extended metadata normalization to support different response shapes returned by Autotask.
+- Improved picklist value handling to support both inline picklist values and URL-based retrieval.
+- Resolved failures in queue, source, and priority picklist detection caused by empty or misparsed field metadata.
+- Stabilized Autotask connection testing across sandbox environments with differing metadata formats.
+
+
 ***
 
 ## v0.1.21

From c68b40170926bea809db2e6daf737a888832d8c1 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Thu, 15 Jan 2026 14:08:59 +0100
Subject: [PATCH 11/63] Auto-commit local changes before build (2026-01-15
 14:08:59)

---
 .last-branch                                  |   2 +-
 .../app/integrations/autotask/client.py       |  67 ++++-
 .../src/backend/app/main/routes_customers.py  | 181 +++++++++++
 .../src/backend/app/migrations.py             |  36 +++
 .../backupchecks/src/backend/app/models.py    |   8 +
 .../src/templates/main/customers.html         | 284 +++++++++++++++++-
 docs/changelog.md                             |   8 +
 7 files changed, 580 insertions(+), 6 deletions(-)

diff --git a/.last-branch b/.last-branch
index 08b1612..21015a3 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260115-08-autotask-entityinfo-fields-shape-fix
+v20260115-09-autotask-customer-company-mapping
diff --git a/containers/backupchecks/src/backend/app/integrations/autotask/client.py b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
index 7f86fb6..6aa9981 100644
--- a/containers/backupchecks/src/backend/app/integrations/autotask/client.py
+++ b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
@@ -14,7 +14,9 @@ class AutotaskZoneInfo:
 
 
 class AutotaskError(RuntimeError):
-    pass
+    def __init__(self, message: str, status_code: Optional[int] = None) -> None:
+        super().__init__(message)
+        self.status_code = status_code
 
 
 class AutotaskClient:
@@ -141,13 +143,18 @@ class AutotaskClient:
                 "Authentication failed (HTTP 401). "
                 "Verify API Username, API Secret, and ApiIntegrationCode. "
                 f"Environment={self.environment}, ZoneInfoBase={zi_base}, ZoneApiUrl={zone.api_url}."
+            ,
+                status_code=401,
             )
         if resp.status_code == 403:
-            raise AutotaskError("Access forbidden (HTTP 403). API user permissions may be insufficient.")
+            raise AutotaskError(
+                "Access forbidden (HTTP 403). API user permissions may be insufficient.",
+                status_code=403,
+            )
         if resp.status_code == 404:
-            raise AutotaskError(f"Resource not found (HTTP 404) for path: {path}")
+            raise AutotaskError(f"Resource not found (HTTP 404) for path: {path}", status_code=404)
         if resp.status_code >= 400:
-            raise AutotaskError(f"Autotask API error (HTTP {resp.status_code}).")
+            raise AutotaskError(f"Autotask API error (HTTP {resp.status_code}).", status_code=resp.status_code)
 
         try:
             return resp.json()
@@ -225,6 +232,58 @@ class AutotaskClient:
         """
         return self._get_ticket_picklist_values(field_names=["source", "sourceid"])
 
+    def search_companies(self, query: str, limit: int = 25) -> List[Dict[str, Any]]:
+        """Search Companies by company name.
+
+        Uses the standard REST query endpoint:
+        GET /Companies/query?search={...}
+
+        Returns a minimal list of dicts with keys: id, companyName, isActive.
+        """
+
+        q = (query or "").strip()
+        if not q:
+            return []
+
+        # Keep payload small and predictable.
+        # Field names in filters are case-insensitive in many tenants, but the docs
+        # commonly show CompanyName.
+        search_payload: Dict[str, Any] = {
+            "filter": [
+                {"op": "contains", "field": "CompanyName", "value": q},
+            ],
+            "maxRecords": int(limit) if int(limit) > 0 else 25,
+        }
+
+        params = {"search": json.dumps(search_payload)}
+        data = self._request("GET", "Companies/query", params=params)
+        items = self._as_items_list(data)
+
+        out: List[Dict[str, Any]] = []
+        for it in items:
+            if not isinstance(it, dict):
+                continue
+            cid = it.get("id")
+            name = it.get("companyName") or it.get("CompanyName") or ""
+            try:
+                cid_int = int(cid)
+            except Exception:
+                continue
+            out.append(
+                {
+                    "id": cid_int,
+                    "companyName": str(name),
+                    "isActive": bool(it.get("isActive", True)),
+                }
+            )
+
+        out.sort(key=lambda x: (x.get("companyName") or "").lower())
+        return out
+
+    def get_company(self, company_id: int) -> Dict[str, Any]:
+        """Fetch a single Company by ID."""
+        return self._request("GET", f"Companies/{int(company_id)}")
+
     def _get_ticket_picklist_values(self, field_names: List[str]) -> List[Dict[str, Any]]:
         """Retrieve picklist values for a Tickets field.
 
diff --git a/containers/backupchecks/src/backend/app/main/routes_customers.py b/containers/backupchecks/src/backend/app/main/routes_customers.py
index 688ecb0..9b01e06 100644
--- a/containers/backupchecks/src/backend/app/main/routes_customers.py
+++ b/containers/backupchecks/src/backend/app/main/routes_customers.py
@@ -6,6 +6,14 @@ from .routes_shared import *  # noqa: F401,F403
 def customers():
     items = Customer.query.order_by(Customer.name.asc()).all()
 
+    settings = _get_or_create_settings()
+    autotask_enabled = bool(getattr(settings, "autotask_enabled", False))
+    autotask_configured = bool(
+        (getattr(settings, "autotask_api_username", None))
+        and (getattr(settings, "autotask_api_password", None))
+        and (getattr(settings, "autotask_tracking_identifier", None))
+    )
+
     rows = []
     for c in items:
         # Count jobs linked to this customer
@@ -19,6 +27,14 @@ def customers():
                 "name": c.name,
                 "active": bool(c.active),
                 "job_count": job_count,
+                "autotask_company_id": getattr(c, "autotask_company_id", None),
+                "autotask_company_name": getattr(c, "autotask_company_name", None),
+                "autotask_mapping_status": getattr(c, "autotask_mapping_status", None),
+                "autotask_last_sync_at": (
+                    getattr(c, "autotask_last_sync_at", None).isoformat(timespec="seconds")
+                    if getattr(c, "autotask_last_sync_at", None)
+                    else None
+                ),
             }
         )
 
@@ -28,9 +44,174 @@ def customers():
         "main/customers.html",
         customers=rows,
         can_manage=can_manage,
+        autotask_enabled=autotask_enabled,
+        autotask_configured=autotask_configured,
     )
 
 
+def _get_autotask_client_or_raise():
+    """Build an AutotaskClient from settings or raise a user-safe exception."""
+    settings = _get_or_create_settings()
+    if not bool(getattr(settings, "autotask_enabled", False)):
+        raise RuntimeError("Autotask integration is disabled.")
+    if not settings.autotask_api_username or not settings.autotask_api_password or not settings.autotask_tracking_identifier:
+        raise RuntimeError("Autotask settings incomplete.")
+
+    from ..integrations.autotask.client import AutotaskClient
+
+    return AutotaskClient(
+        username=settings.autotask_api_username,
+        password=settings.autotask_api_password,
+        api_integration_code=settings.autotask_tracking_identifier,
+        environment=(settings.autotask_environment or "production"),
+    )
+
+
+@main_bp.get("/api/autotask/companies/search")
+@login_required
+@roles_required("admin", "operator")
+def api_autotask_companies_search():
+    q = (request.args.get("q") or "").strip()
+    if not q:
+        return jsonify({"status": "ok", "items": []})
+
+    try:
+        client = _get_autotask_client_or_raise()
+        items = client.search_companies(q, limit=25)
+        return jsonify({"status": "ok", "items": items})
+    except Exception as exc:
+        return jsonify({"status": "error", "message": str(exc) or "Search failed."}), 400
+
+
+def _normalize_company_name(company: dict) -> str:
+    return str(company.get("companyName") or company.get("CompanyName") or company.get("name") or "").strip()
+
+
+@main_bp.get("/api/customers/<int:customer_id>/autotask-mapping")
+@login_required
+@roles_required("admin", "operator", "viewer")
+def api_customer_autotask_mapping_get(customer_id: int):
+    c = Customer.query.get_or_404(customer_id)
+    return jsonify(
+        {
+            "status": "ok",
+            "customer": {
+                "id": c.id,
+                "autotask_company_id": getattr(c, "autotask_company_id", None),
+                "autotask_company_name": getattr(c, "autotask_company_name", None),
+                "autotask_mapping_status": getattr(c, "autotask_mapping_status", None),
+                "autotask_last_sync_at": (
+                    getattr(c, "autotask_last_sync_at", None).isoformat(timespec="seconds")
+                    if getattr(c, "autotask_last_sync_at", None)
+                    else None
+                ),
+            },
+        }
+    )
+
+
+@main_bp.post("/api/customers/<int:customer_id>/autotask-mapping")
+@login_required
+@roles_required("admin", "operator")
+def api_customer_autotask_mapping_set(customer_id: int):
+    c = Customer.query.get_or_404(customer_id)
+    payload = request.get_json(silent=True) or {}
+    company_id = payload.get("company_id")
+    try:
+        company_id_int = int(company_id)
+    except Exception:
+        return jsonify({"status": "error", "message": "Invalid company_id."}), 400
+
+    try:
+        client = _get_autotask_client_or_raise()
+        company = client.get_company(company_id_int)
+        name = _normalize_company_name(company)
+
+        c.autotask_company_id = company_id_int
+        c.autotask_company_name = name
+        c.autotask_mapping_status = "ok"
+        c.autotask_last_sync_at = datetime.utcnow()
+
+        db.session.commit()
+        return jsonify({"status": "ok"})
+    except Exception as exc:
+        db.session.rollback()
+        return jsonify({"status": "error", "message": str(exc) or "Failed to set mapping."}), 400
+
+
+@main_bp.post("/api/customers/<int:customer_id>/autotask-mapping/clear")
+@login_required
+@roles_required("admin", "operator")
+def api_customer_autotask_mapping_clear(customer_id: int):
+    c = Customer.query.get_or_404(customer_id)
+    try:
+        c.autotask_company_id = None
+        c.autotask_company_name = None
+        c.autotask_mapping_status = None
+        c.autotask_last_sync_at = datetime.utcnow()
+        db.session.commit()
+        return jsonify({"status": "ok"})
+    except Exception as exc:
+        db.session.rollback()
+        return jsonify({"status": "error", "message": str(exc) or "Failed to clear mapping."}), 400
+
+
+@main_bp.post("/api/customers/<int:customer_id>/autotask-mapping/refresh")
+@login_required
+@roles_required("admin", "operator")
+def api_customer_autotask_mapping_refresh(customer_id: int):
+    from ..integrations.autotask.client import AutotaskError
+
+    c = Customer.query.get_or_404(customer_id)
+    company_id = getattr(c, "autotask_company_id", None)
+    if not company_id:
+        return jsonify({"status": "ok", "mapping_status": None})
+
+    try:
+        client = _get_autotask_client_or_raise()
+        company = client.get_company(int(company_id))
+        name = _normalize_company_name(company)
+
+        prev = (getattr(c, "autotask_company_name", None) or "").strip()
+        if prev and name and prev != name:
+            c.autotask_company_name = name
+            c.autotask_mapping_status = "renamed"
+        else:
+            c.autotask_company_name = name
+            c.autotask_mapping_status = "ok"
+        c.autotask_last_sync_at = datetime.utcnow()
+
+        db.session.commit()
+        return jsonify({"status": "ok", "mapping_status": c.autotask_mapping_status, "company_name": c.autotask_company_name})
+    except AutotaskError as exc:
+        try:
+            code = getattr(exc, "status_code", None)
+        except Exception:
+            code = None
+
+        # 404 -> deleted/missing company in Autotask
+        if code == 404:
+            try:
+                c.autotask_mapping_status = "invalid"
+                c.autotask_last_sync_at = datetime.utcnow()
+                db.session.commit()
+            except Exception:
+                db.session.rollback()
+            return jsonify({"status": "ok", "mapping_status": "invalid"})
+
+        # Other errors: keep mapping but mark as missing (temporary/unreachable)
+        try:
+            c.autotask_mapping_status = "missing"
+            c.autotask_last_sync_at = datetime.utcnow()
+            db.session.commit()
+        except Exception:
+            db.session.rollback()
+        return jsonify({"status": "ok", "mapping_status": "missing", "message": str(exc)})
+    except Exception as exc:
+        db.session.rollback()
+        return jsonify({"status": "error", "message": str(exc) or "Refresh failed."}), 400
+
+
 @main_bp.route("/customers/create", methods=["POST"])
 @login_required
 @roles_required("admin", "operator")
diff --git a/containers/backupchecks/src/backend/app/migrations.py b/containers/backupchecks/src/backend/app/migrations.py
index 71a697e..6c21f5e 100644
--- a/containers/backupchecks/src/backend/app/migrations.py
+++ b/containers/backupchecks/src/backend/app/migrations.py
@@ -188,6 +188,41 @@ def migrate_system_settings_autotask_integration() -> None:
         print(f"[migrations] Failed to migrate system_settings autotask integration columns: {exc}")
 
 
+def migrate_customers_autotask_company_mapping() -> None:
+    """Add Autotask company mapping columns to customers if missing.
+
+    Columns:
+    - autotask_company_id (INTEGER NULL)
+    - autotask_company_name (VARCHAR(255) NULL)
+    - autotask_mapping_status (VARCHAR(20) NULL)
+    - autotask_last_sync_at (TIMESTAMP NULL)
+    """
+
+    table = "customers"
+    columns = [
+        ("autotask_company_id", "INTEGER NULL"),
+        ("autotask_company_name", "VARCHAR(255) NULL"),
+        ("autotask_mapping_status", "VARCHAR(20) NULL"),
+        ("autotask_last_sync_at", "TIMESTAMP NULL"),
+    ]
+
+    try:
+        engine = db.get_engine()
+    except Exception as exc:
+        print(f"[migrations] Could not get engine for customers autotask mapping migration: {exc}")
+        return
+
+    try:
+        with engine.begin() as conn:
+            for column, ddl in columns:
+                if _column_exists_on_conn(conn, table, column):
+                    continue
+                conn.execute(text(f'ALTER TABLE "{table}" ADD COLUMN {column} {ddl}'))
+        print("[migrations] migrate_customers_autotask_company_mapping completed.")
+    except Exception as exc:
+        print(f"[migrations] Failed to migrate customers autotask company mapping columns: {exc}")
+
+
 
 
 
@@ -843,6 +878,7 @@ def run_migrations() -> None:
     migrate_system_settings_daily_jobs_start_date()
     migrate_system_settings_ui_timezone()
     migrate_system_settings_autotask_integration()
+    migrate_customers_autotask_company_mapping()
     migrate_mail_messages_columns()
     migrate_mail_messages_parse_columns()
     migrate_mail_messages_approval_columns()
diff --git a/containers/backupchecks/src/backend/app/models.py b/containers/backupchecks/src/backend/app/models.py
index 3aec257..e72a846 100644
--- a/containers/backupchecks/src/backend/app/models.py
+++ b/containers/backupchecks/src/backend/app/models.py
@@ -153,6 +153,14 @@ class Customer(db.Model):
     name = db.Column(db.String(255), unique=True, nullable=False)
     active = db.Column(db.Boolean, nullable=False, default=True)
 
+    # Autotask company mapping (Phase 3)
+    # Company ID is leading; name is cached for UI display.
+    autotask_company_id = db.Column(db.Integer, nullable=True)
+    autotask_company_name = db.Column(db.String(255), nullable=True)
+    # Mapping status: ok | renamed | missing | invalid
+    autotask_mapping_status = db.Column(db.String(20), nullable=True)
+    autotask_last_sync_at = db.Column(db.DateTime, nullable=True)
+
     created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
     updated_at = db.Column(
         db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False
diff --git a/containers/backupchecks/src/templates/main/customers.html b/containers/backupchecks/src/templates/main/customers.html
index 153a546..91ec891 100644
--- a/containers/backupchecks/src/templates/main/customers.html
+++ b/containers/backupchecks/src/templates/main/customers.html
@@ -29,6 +29,8 @@
         <th scope="col">Customer</th>
         <th scope="col">Active</th>
         <th scope="col">Number of jobs</th>
+        <th scope="col">Autotask company</th>
+        <th scope="col">Autotask mapping</th>
         {% if can_manage %}
           <th scope="col">Actions</th>
         {% endif %}
@@ -46,6 +48,7 @@
                 <span class="badge bg-secondary">Inactive</span>
               {% endif %}
             </td>
+
             <td>
               {% if c.job_count > 0 %}
                 {{ c.job_count }}
@@ -53,6 +56,36 @@
                 <span class="text-danger fw-bold">0</span>
               {% endif %}
             </td>
+
+            <td>
+              {% if c.autotask_company_id %}
+                <span class="fw-semibold">{{ c.autotask_company_name or 'Unknown' }}</span>
+                <div class="text-muted small">ID: {{ c.autotask_company_id }}</div>
+              {% else %}
+                <span class="text-muted">Not mapped</span>
+              {% endif %}
+            </td>
+
+            <td>
+              {% set st = (c.autotask_mapping_status or '').lower() %}
+              {% if not c.autotask_company_id %}
+                <span class="badge bg-secondary">Not mapped</span>
+              {% elif st == 'ok' %}
+                <span class="badge bg-success">OK</span>
+              {% elif st == 'renamed' %}
+                <span class="badge bg-warning text-dark">Renamed</span>
+              {% elif st == 'missing' %}
+                <span class="badge bg-warning text-dark">Missing</span>
+              {% elif st == 'invalid' %}
+                <span class="badge bg-danger">Invalid</span>
+              {% else %}
+                <span class="badge bg-secondary">Unknown</span>
+              {% endif %}
+
+              {% if c.autotask_last_sync_at %}
+                <div class="text-muted small">Checked: {{ c.autotask_last_sync_at }}</div>
+              {% endif %}
+            </td>
             {% if can_manage %}
               <td>
                 <button
@@ -63,6 +96,10 @@
                   data-id="{{ c.id }}"
                   data-name="{{ c.name }}"
                   data-active="{{ '1' if c.active else '0' }}"
+                  data-autotask-company-id="{{ c.autotask_company_id or '' }}"
+                  data-autotask-company-name="{{ c.autotask_company_name or '' }}"
+                  data-autotask-mapping-status="{{ c.autotask_mapping_status or '' }}"
+                  data-autotask-last-sync-at="{{ c.autotask_last_sync_at or '' }}"
                 >
                   Edit
                 </button>
@@ -82,7 +119,7 @@
         {% endfor %}
       {% else %}
         <tr>
-          <td colspan="{% if can_manage %}4{% else %}3{% endif %}" class="text-center text-muted py-3">
+          <td colspan="{% if can_manage %}6{% else %}5{% endif %}" class="text-center text-muted py-3">
             No customers found.
           </td>
         </tr>
@@ -130,6 +167,36 @@
               Active
             </label>
           </div>
+
+          <hr class="my-4" />
+
+          <h6 class="mb-2">Autotask mapping</h6>
+          {% if autotask_enabled and autotask_configured %}
+            <div class="mb-2">
+              <div class="small text-muted">Current mapping</div>
+              <div id="autotaskCurrentMapping" class="fw-semibold">Not mapped</div>
+              <div id="autotaskCurrentMappingMeta" class="text-muted small"></div>
+            </div>
+
+            <div class="input-group input-group-sm mb-2">
+              <input type="text" class="form-control" id="autotaskCompanySearch" placeholder="Search Autotask companies" autocomplete="off" />
+              <button class="btn btn-outline-secondary" type="button" id="autotaskCompanySearchBtn">Search</button>
+            </div>
+
+            <div id="autotaskCompanyResults" class="border rounded p-2" style="max-height: 220px; overflow:auto;"></div>
+
+            <div class="d-flex gap-2 mt-2">
+              <button type="button" class="btn btn-sm btn-outline-primary" id="autotaskSetMappingBtn" disabled>Set mapping</button>
+              <button type="button" class="btn btn-sm btn-outline-secondary" id="autotaskRefreshMappingBtn">Refresh status</button>
+              <button type="button" class="btn btn-sm btn-outline-danger" id="autotaskClearMappingBtn">Clear mapping</button>
+            </div>
+
+            <div id="autotaskMappingMsg" class="small text-muted mt-2"></div>
+          {% else %}
+            <div class="text-muted small">
+              Autotask integration is not available. Enable and configure it in Settings → Extensions &amp; Integrations → Autotask.
+            </div>
+          {% endif %}
         </div>
         <div class="modal-footer">
           <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">Cancel</button>
@@ -152,6 +219,89 @@
       var nameInput = document.getElementById("edit_customer_name");
       var activeInput = document.getElementById("edit_customer_active");
 
+      // Autotask mapping UI (only present when integration is enabled/configured)
+      var atCurrent = document.getElementById("autotaskCurrentMapping");
+      var atCurrentMeta = document.getElementById("autotaskCurrentMappingMeta");
+      var atSearchInput = document.getElementById("autotaskCompanySearch");
+      var atSearchBtn = document.getElementById("autotaskCompanySearchBtn");
+      var atResults = document.getElementById("autotaskCompanyResults");
+      var atMsg = document.getElementById("autotaskMappingMsg");
+      var atSetBtn = document.getElementById("autotaskSetMappingBtn");
+      var atRefreshBtn = document.getElementById("autotaskRefreshMappingBtn");
+      var atClearBtn = document.getElementById("autotaskClearMappingBtn");
+
+      var currentCustomerId = null;
+      var selectedCompanyId = null;
+
+      function setMsg(text, isError) {
+        if (!atMsg) {
+          return;
+        }
+        atMsg.textContent = text || "";
+        if (isError) {
+          atMsg.classList.remove("text-muted");
+          atMsg.classList.add("text-danger");
+        } else {
+          atMsg.classList.remove("text-danger");
+          atMsg.classList.add("text-muted");
+        }
+      }
+
+      function renderCurrentMapping(companyId, companyName, mappingStatus, lastSyncAt) {
+        if (!atCurrent || !atCurrentMeta) {
+          return;
+        }
+        if (!companyId) {
+          atCurrent.textContent = "Not mapped";
+          atCurrentMeta.textContent = "";
+          return;
+        }
+        atCurrent.textContent = (companyName || "Unknown") + " (ID: " + companyId + ")";
+
+        var parts = [];
+        if (mappingStatus) {
+          parts.push("Status: " + mappingStatus);
+        }
+        if (lastSyncAt) {
+          parts.push("Checked: " + lastSyncAt);
+        }
+        atCurrentMeta.textContent = parts.join(" • ");
+      }
+
+      function clearResults() {
+        if (!atResults) {
+          return;
+        }
+        atResults.innerHTML = "<div class=\"text-muted small\">No results.</div>";
+      }
+
+      function setSelectedCompanyId(cid) {
+        selectedCompanyId = cid;
+        if (atSetBtn) {
+          atSetBtn.disabled = !selectedCompanyId;
+        }
+      }
+
+      async function postJson(url, body) {
+        var resp = await fetch(url, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          credentials: "same-origin",
+          body: JSON.stringify(body || {}),
+        });
+        var data = null;
+        try {
+          data = await resp.json();
+        } catch (e) {
+          data = null;
+        }
+        if (!resp.ok) {
+          var msg = (data && data.message) ? data.message : ("Request failed (" + resp.status + ").");
+          throw new Error(msg);
+        }
+        return data;
+      }
+
       var editButtons = document.querySelectorAll(".customer-edit-btn");
       editButtons.forEach(function (btn) {
         btn.addEventListener("click", function () {
@@ -165,8 +315,140 @@
           if (id) {
             editForm.action = "{{ url_for('main.customers_edit', customer_id=0) }}".replace("0", id);
           }
+
+          // Autotask: seed current mapping from row data attributes
+          currentCustomerId = id || null;
+          if (atResults) {
+            clearResults();
+          }
+          setSelectedCompanyId(null);
+          setMsg("", false);
+
+          if (atCurrent) {
+            var atCompanyId = btn.getAttribute("data-autotask-company-id") || "";
+            var atCompanyName = btn.getAttribute("data-autotask-company-name") || "";
+            var atStatus = btn.getAttribute("data-autotask-mapping-status") || "";
+            var atLast = btn.getAttribute("data-autotask-last-sync-at") || "";
+            renderCurrentMapping(atCompanyId, atCompanyName, atStatus, atLast);
+          }
         });
       });
+
+      if (atSearchBtn && atSearchInput && atResults) {
+        atSearchBtn.addEventListener("click", async function () {
+          var q = (atSearchInput.value || "").trim();
+          if (!q) {
+            setMsg("Enter a search term.", true);
+            return;
+          }
+          setMsg("Searching...", false);
+          setSelectedCompanyId(null);
+          atResults.innerHTML = "<div class=\"text-muted small\">Searching...</div>";
+
+          try {
+            var resp = await fetch("/api/autotask/companies/search?q=" + encodeURIComponent(q), {
+              method: "GET",
+              credentials: "same-origin",
+            });
+            var data = await resp.json();
+            if (!resp.ok || !data || data.status !== "ok") {
+              throw new Error((data && data.message) ? data.message : "Search failed.");
+            }
+            var items = data.items || [];
+            if (!items.length) {
+              atResults.innerHTML = "<div class=\"text-muted small\">No companies found.</div>";
+              setMsg("No companies found.", false);
+              return;
+            }
+            var html = "";
+            items.forEach(function (it) {
+              var cid = it.id;
+              var name = it.companyName || it.name || ("Company #" + cid);
+              var active = (it.isActive === false) ? " (inactive)" : "";
+              html +=
+                "<div class=\"form-check\">" +
+                "<input class=\"form-check-input\" type=\"radio\" name=\"autotaskCompanyPick\" id=\"at_company_" + cid + "\" value=\"" + cid + "\" />" +
+                "<label class=\"form-check-label\" for=\"at_company_" + cid + "\">" +
+                name.replace(/</g, "&lt;").replace(/>/g, "&gt;") +
+                " <span class=\"text-muted\">(ID: " + cid + ")</span>" +
+                "<span class=\"text-muted\">" + active + "</span>" +
+                "</label>" +
+                "</div>";
+            });
+            atResults.innerHTML = html;
+
+            var radios = atResults.querySelectorAll("input[name='autotaskCompanyPick']");
+            radios.forEach(function (r) {
+              r.addEventListener("change", function () {
+                setSelectedCompanyId(r.value);
+                setMsg("Selected company ID: " + r.value, false);
+              });
+            });
+
+            setMsg("Select a company and click Set mapping.", false);
+          } catch (e) {
+            atResults.innerHTML = "<div class=\"text-muted small\">No results.</div>";
+            setMsg(e && e.message ? e.message : "Search failed.", true);
+          }
+        });
+      }
+
+      if (atSetBtn) {
+        atSetBtn.addEventListener("click", async function () {
+          if (!currentCustomerId) {
+            setMsg("No customer selected.", true);
+            return;
+          }
+          if (!selectedCompanyId) {
+            setMsg("Select a company first.", true);
+            return;
+          }
+          atSetBtn.disabled = true;
+          setMsg("Saving mapping...", false);
+          try {
+            await postJson("/api/customers/" + currentCustomerId + "/autotask-mapping", { company_id: selectedCompanyId });
+            window.location.reload();
+          } catch (e) {
+            setMsg(e && e.message ? e.message : "Failed to set mapping.", true);
+            atSetBtn.disabled = false;
+          }
+        });
+      }
+
+      if (atRefreshBtn) {
+        atRefreshBtn.addEventListener("click", async function () {
+          if (!currentCustomerId) {
+            setMsg("No customer selected.", true);
+            return;
+          }
+          setMsg("Refreshing status...", false);
+          try {
+            await postJson("/api/customers/" + currentCustomerId + "/autotask-mapping/refresh", {});
+            window.location.reload();
+          } catch (e) {
+            setMsg(e && e.message ? e.message : "Refresh failed.", true);
+          }
+        });
+      }
+
+      if (atClearBtn) {
+        atClearBtn.addEventListener("click", async function () {
+          if (!currentCustomerId) {
+            setMsg("No customer selected.", true);
+            return;
+          }
+          if (!confirm("Clear Autotask mapping for this customer?")) {
+            return;
+          }
+          setMsg("Clearing mapping...", false);
+          try {
+            await postJson("/api/customers/" + currentCustomerId + "/autotask-mapping/clear", {});
+            window.location.reload();
+          } catch (e) {
+            setMsg(e && e.message ? e.message : "Clear failed.", true);
+          }
+        });
+      }
     });
   })();
 </script>
diff --git a/docs/changelog.md b/docs/changelog.md
index 6955786..610ef1b 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -73,6 +73,14 @@ Changes:
 - Resolved failures in queue, source, and priority picklist detection caused by empty or misparsed field metadata.
 - Stabilized Autotask connection testing across sandbox environments with differing metadata formats.
 
+## v20260115-09-autotask-customer-company-mapping
+
+- Added explicit Autotask company mapping to customers using ID-based linkage.
+- Extended customer data model with Autotask company ID, cached company name, mapping status, and last sync timestamp.
+- Implemented Autotask company search and lookup endpoints for customer mapping.
+- Added mapping status handling to detect renamed, missing, or invalid Autotask companies.
+- Updated Customers UI to allow searching, selecting, refreshing, and clearing Autotask company mappings.
+- Ensured mappings remain stable when Autotask company names change and block future ticket actions when mappings are invalid.
 
 ***
 

From 186807b098eeefa3ff20638c424de635d6f7f784 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Thu, 15 Jan 2026 14:14:29 +0100
Subject: [PATCH 12/63] Auto-commit local changes before build (2026-01-15
 14:14:29)

---
 .last-branch                                  |  2 +-
 .../src/backend/app/main/routes_customers.py  | 33 +++++++++++++++++--
 docs/changelog.md                             |  8 +++++
 3 files changed, 40 insertions(+), 3 deletions(-)

diff --git a/.last-branch b/.last-branch
index 21015a3..712b150 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260115-09-autotask-customer-company-mapping
+v20260115-10-autotask-customers-settings-helper-fix
diff --git a/containers/backupchecks/src/backend/app/main/routes_customers.py b/containers/backupchecks/src/backend/app/main/routes_customers.py
index 9b01e06..aaf202f 100644
--- a/containers/backupchecks/src/backend/app/main/routes_customers.py
+++ b/containers/backupchecks/src/backend/app/main/routes_customers.py
@@ -1,12 +1,41 @@
 from .routes_shared import *  # noqa: F401,F403
 
+# Explicit imports for robustness across mixed deployments.
+from datetime import datetime
+
+from ..database import db
+from ..models import SystemSettings
+
+
+def _get_or_create_settings_local():
+    """Return SystemSettings, creating a default row if missing.
+
+    This module should not depend on star-imported helpers for settings.
+    Mixed deployments (partial container updates) can otherwise raise a
+    NameError on /customers when the shared helper is not present.
+    """
+
+    settings = SystemSettings.query.first()
+    if settings is None:
+        settings = SystemSettings(
+            auto_import_enabled=False,
+            auto_import_interval_minutes=15,
+            auto_import_max_items=50,
+            manual_import_batch_size=50,
+            auto_import_cutoff_date=datetime.utcnow().date(),
+            ingest_eml_retention_days=7,
+        )
+        db.session.add(settings)
+        db.session.commit()
+    return settings
+
 @main_bp.route("/customers")
 @login_required
 @roles_required("admin", "operator", "viewer")
 def customers():
     items = Customer.query.order_by(Customer.name.asc()).all()
 
-    settings = _get_or_create_settings()
+    settings = _get_or_create_settings_local()
     autotask_enabled = bool(getattr(settings, "autotask_enabled", False))
     autotask_configured = bool(
         (getattr(settings, "autotask_api_username", None))
@@ -51,7 +80,7 @@ def customers():
 
 def _get_autotask_client_or_raise():
     """Build an AutotaskClient from settings or raise a user-safe exception."""
-    settings = _get_or_create_settings()
+    settings = _get_or_create_settings_local()
     if not bool(getattr(settings, "autotask_enabled", False)):
         raise RuntimeError("Autotask integration is disabled.")
     if not settings.autotask_api_username or not settings.autotask_api_password or not settings.autotask_tracking_identifier:
diff --git a/docs/changelog.md b/docs/changelog.md
index 610ef1b..9e4b2d9 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -82,6 +82,14 @@ Changes:
 - Updated Customers UI to allow searching, selecting, refreshing, and clearing Autotask company mappings.
 - Ensured mappings remain stable when Autotask company names change and block future ticket actions when mappings are invalid.
 
+## v20260115-10-autotask-customers-settings-helper-fix
+
+- Fixed /customers crash caused by missing _get_or_create_settings by removing reliance on shared star-imported helpers.
+- Added a local SystemSettings get-or-create helper in customers routes to prevent runtime NameError in mixed/partial deployments.
+- Added explicit imports for SystemSettings, db, and datetime to keep the Customers page stable across versions.
+
+
+
 ***
 
 ## v0.1.21

From 49f6d4171559b55076600b32780c782423009fec Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Thu, 15 Jan 2026 14:24:54 +0100
Subject: [PATCH 13/63] Auto-commit local changes before build (2026-01-15
 14:24:54)

---
 .last-branch                                  |  2 +-
 .../src/backend/app/main/routes_customers.py  | 20 ++++++++++++++++++-
 docs/changelog.md                             |  4 ++++
 3 files changed, 24 insertions(+), 2 deletions(-)

diff --git a/.last-branch b/.last-branch
index 712b150..fe28a48 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260115-10-autotask-customers-settings-helper-fix
+v20260115-11-autotask-companyname-unwrap
diff --git a/containers/backupchecks/src/backend/app/main/routes_customers.py b/containers/backupchecks/src/backend/app/main/routes_customers.py
index aaf202f..f57ca44 100644
--- a/containers/backupchecks/src/backend/app/main/routes_customers.py
+++ b/containers/backupchecks/src/backend/app/main/routes_customers.py
@@ -113,7 +113,25 @@ def api_autotask_companies_search():
 
 
 def _normalize_company_name(company: dict) -> str:
-    return str(company.get("companyName") or company.get("CompanyName") or company.get("name") or "").strip()
+    # Autotask REST payload shapes vary between tenants/endpoints.
+    # - Some single-entity GETs return {"item": {...}}
+    # - Some may return {"items": [{...}]}
+    if isinstance(company, dict):
+        item = company.get("item")
+        if isinstance(item, dict):
+            company = item
+        else:
+            items = company.get("items")
+            if isinstance(items, list) and items and isinstance(items[0], dict):
+                company = items[0]
+
+    return str(
+        (company or {}).get("companyName")
+        or (company or {}).get("CompanyName")
+        or (company or {}).get("name")
+        or (company or {}).get("Name")
+        or ""
+    ).strip()
 
 
 @main_bp.get("/api/customers/<int:customer_id>/autotask-mapping")
diff --git a/docs/changelog.md b/docs/changelog.md
index 9e4b2d9..ec0cd13 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -88,7 +88,11 @@ Changes:
 - Added a local SystemSettings get-or-create helper in customers routes to prevent runtime NameError in mixed/partial deployments.
 - Added explicit imports for SystemSettings, db, and datetime to keep the Customers page stable across versions.
 
+## v20260115-11-autotask-companyname-unwrap
 
+- Fixed Autotask company name being shown as "Unknown" by correctly unwrapping nested Autotask API responses.
+- Improved company lookup handling to support different response shapes (single item and collection wrappers).
+- Ensured the cached Autotask company name is stored and displayed consistently after mapping and refresh.
 
 ***
 

From 49fd29a6f2c75ca228d1d9899f9fa5904a45ac65 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Thu, 15 Jan 2026 14:36:50 +0100
Subject: [PATCH 14/63] Auto-commit local changes before build (2026-01-15
 14:36:50)

---
 .last-branch                                  |  2 +-
 .../src/backend/app/main/routes_customers.py  | 67 +++++++++++++++++++
 .../src/templates/main/customers.html         | 49 ++++++++++++++
 docs/changelog.md                             |  6 ++
 4 files changed, 123 insertions(+), 1 deletion(-)

diff --git a/.last-branch b/.last-branch
index fe28a48..dad6799 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260115-11-autotask-companyname-unwrap
+v20260115-12-autotask-customers-refreshall-mappings
diff --git a/containers/backupchecks/src/backend/app/main/routes_customers.py b/containers/backupchecks/src/backend/app/main/routes_customers.py
index f57ca44..e54ab83 100644
--- a/containers/backupchecks/src/backend/app/main/routes_customers.py
+++ b/containers/backupchecks/src/backend/app/main/routes_customers.py
@@ -259,6 +259,73 @@ def api_customer_autotask_mapping_refresh(customer_id: int):
         return jsonify({"status": "error", "message": str(exc) or "Refresh failed."}), 400
 
 
+@main_bp.post("/api/customers/autotask-mapping/refresh-all")
+@login_required
+@roles_required("admin", "operator")
+def api_customers_autotask_mapping_refresh_all():
+    """Refresh mapping status for all customers that have an Autotask company ID."""
+
+    from ..integrations.autotask.client import AutotaskError
+
+    customers = Customer.query.filter(Customer.autotask_company_id.isnot(None)).all()
+    if not customers:
+        return jsonify({"status": "ok", "refreshed": 0, "counts": {"ok": 0, "renamed": 0, "missing": 0, "invalid": 0}})
+
+    try:
+        client = _get_autotask_client_or_raise()
+    except Exception as exc:
+        return jsonify({"status": "error", "message": str(exc) or "Autotask is not configured."}), 400
+
+    counts = {"ok": 0, "renamed": 0, "missing": 0, "invalid": 0}
+    refreshed = 0
+
+    for c in customers:
+        company_id = getattr(c, "autotask_company_id", None)
+        if not company_id:
+            continue
+        try:
+            company = client.get_company(int(company_id))
+            name = _normalize_company_name(company)
+
+            prev = (getattr(c, "autotask_company_name", None) or "").strip()
+            if prev and name and prev != name:
+                c.autotask_company_name = name
+                c.autotask_mapping_status = "renamed"
+                counts["renamed"] += 1
+            else:
+                c.autotask_company_name = name
+                c.autotask_mapping_status = "ok"
+                counts["ok"] += 1
+            c.autotask_last_sync_at = datetime.utcnow()
+            refreshed += 1
+        except AutotaskError as exc:
+            try:
+                code = getattr(exc, "status_code", None)
+            except Exception:
+                code = None
+
+            if code == 404:
+                c.autotask_mapping_status = "invalid"
+                counts["invalid"] += 1
+            else:
+                c.autotask_mapping_status = "missing"
+                counts["missing"] += 1
+            c.autotask_last_sync_at = datetime.utcnow()
+            refreshed += 1
+        except Exception:
+            c.autotask_mapping_status = "missing"
+            c.autotask_last_sync_at = datetime.utcnow()
+            counts["missing"] += 1
+            refreshed += 1
+
+    try:
+        db.session.commit()
+        return jsonify({"status": "ok", "refreshed": refreshed, "counts": counts})
+    except Exception as exc:
+        db.session.rollback()
+        return jsonify({"status": "error", "message": str(exc) or "Failed to refresh all mappings."}), 400
+
+
 @main_bp.route("/customers/create", methods=["POST"])
 @login_required
 @roles_required("admin", "operator")
diff --git a/containers/backupchecks/src/templates/main/customers.html b/containers/backupchecks/src/templates/main/customers.html
index 91ec891..024fb51 100644
--- a/containers/backupchecks/src/templates/main/customers.html
+++ b/containers/backupchecks/src/templates/main/customers.html
@@ -19,6 +19,11 @@
   </form>
 
   <a class="btn btn-outline-secondary btn-sm" href="{{ url_for('main.customers_export') }}">Export CSV</a>
+
+  {% if autotask_enabled and autotask_configured %}
+    <button type="button" class="btn btn-outline-secondary btn-sm" id="autotaskRefreshAllMappingsBtn" style="white-space: nowrap;">Refresh all Autotask mappings</button>
+    <span class="small text-muted" id="autotaskRefreshAllMappingsMsg"></span>
+  {% endif %}
 </div>
 {% endif %}
 
@@ -219,6 +224,10 @@
       var nameInput = document.getElementById("edit_customer_name");
       var activeInput = document.getElementById("edit_customer_active");
 
+      // Top-level refresh-all (only present when integration is enabled/configured)
+      var refreshAllBtn = document.getElementById("autotaskRefreshAllMappingsBtn");
+      var refreshAllMsg = document.getElementById("autotaskRefreshAllMappingsMsg");
+
       // Autotask mapping UI (only present when integration is enabled/configured)
       var atCurrent = document.getElementById("autotaskCurrentMapping");
       var atCurrentMeta = document.getElementById("autotaskCurrentMappingMeta");
@@ -233,6 +242,20 @@
       var currentCustomerId = null;
       var selectedCompanyId = null;
 
+      function setRefreshAllMsg(text, isError) {
+        if (!refreshAllMsg) {
+          return;
+        }
+        refreshAllMsg.textContent = text || "";
+        if (isError) {
+          refreshAllMsg.classList.remove("text-muted");
+          refreshAllMsg.classList.add("text-danger");
+        } else {
+          refreshAllMsg.classList.remove("text-danger");
+          refreshAllMsg.classList.add("text-muted");
+        }
+      }
+
       function setMsg(text, isError) {
         if (!atMsg) {
           return;
@@ -302,6 +325,32 @@
         return data;
       }
 
+      if (refreshAllBtn) {
+        refreshAllBtn.addEventListener("click", async function () {
+          if (!confirm("Refresh mapping status for all mapped customers?")) {
+            return;
+          }
+          refreshAllBtn.disabled = true;
+          setRefreshAllMsg("Refreshing...", false);
+          try {
+            var data = await postJson("/api/customers/autotask-mapping/refresh-all", {});
+            var counts = (data && data.counts) ? data.counts : null;
+            if (counts) {
+              setRefreshAllMsg(
+                "Done. OK: " + (counts.ok || 0) + ", Renamed: " + (counts.renamed || 0) + ", Missing: " + (counts.missing || 0) + ", Invalid: " + (counts.invalid || 0) + ".",
+                false
+              );
+            } else {
+              setRefreshAllMsg("Done.", false);
+            }
+            window.location.reload();
+          } catch (e) {
+            setRefreshAllMsg(e && e.message ? e.message : "Refresh failed.", true);
+            refreshAllBtn.disabled = false;
+          }
+        });
+      }
+
       var editButtons = document.querySelectorAll(".customer-edit-btn");
       editButtons.forEach(function (btn) {
         btn.addEventListener("click", function () {
diff --git a/docs/changelog.md b/docs/changelog.md
index ec0cd13..454b22e 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -94,6 +94,12 @@ Changes:
 - Improved company lookup handling to support different response shapes (single item and collection wrappers).
 - Ensured the cached Autotask company name is stored and displayed consistently after mapping and refresh.
 
+## v20260115-12-autotask-customers-refreshall-mappings
+
+- Added a “Refresh all Autotask mappings” button on the Customers page to validate all mapped customers in one action.
+- Implemented a new backend endpoint to refresh mapping status for all customers with an Autotask Company ID and return a status summary (ok/renamed/missing/invalid).
+- Updated the Customers UI to call the refresh-all endpoint, show a short result summary, and reload to reflect updated mapping states.
+
 ***
 
 ## v0.1.21

From 3564bcf62f458d715bccdeb769ccaa83bcbc9efc Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Thu, 15 Jan 2026 15:05:42 +0100
Subject: [PATCH 15/63] Auto-commit local changes before build (2026-01-15
 15:05:42)

---
 .last-branch                                  |   2 +-
 .../app/integrations/autotask/client.py       |  36 ++-
 .../src/backend/app/main/routes_run_checks.py | 274 +++++++++++++++++-
 .../src/backend/app/migrations.py             |  62 ++++
 .../backupchecks/src/backend/app/models.py    |   8 +
 .../src/templates/main/run_checks.html        | 106 ++++---
 6 files changed, 443 insertions(+), 45 deletions(-)

diff --git a/.last-branch b/.last-branch
index dad6799..4c130c6 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260115-12-autotask-customers-refreshall-mappings
+v20260115-13-autotask-runchecks-create-ticket
diff --git a/containers/backupchecks/src/backend/app/integrations/autotask/client.py b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
index 6aa9981..4989ec1 100644
--- a/containers/backupchecks/src/backend/app/integrations/autotask/client.py
+++ b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
@@ -105,7 +105,13 @@ class AutotaskClient:
             "Accept": "application/json",
         }
 
-    def _request(self, method: str, path: str, params: Optional[Dict[str, Any]] = None) -> Any:
+    def _request(
+        self,
+        method: str,
+        path: str,
+        params: Optional[Dict[str, Any]] = None,
+        json_body: Optional[Dict[str, Any]] = None,
+    ) -> Any:
         zone = self.get_zone_info()
         base = zone.api_url.rstrip("/")
         url = f"{base}/v1.0/{path.lstrip('/')}"
@@ -120,6 +126,7 @@ class AutotaskClient:
                 url=url,
                 headers=h,
                 params=params or None,
+                json=json_body if json_body is not None else None,
                 auth=(self.username, self.password) if use_basic_auth else None,
                 timeout=self.timeout_seconds,
             )
@@ -389,3 +396,30 @@ class AutotaskClient:
             raise AutotaskError("Tickets.priority metadata did not include picklist values.")
 
         return self._call_picklist_values(picklist_values)
+
+    def create_ticket(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """Create a Ticket in Autotask.
+
+        Uses POST /Tickets.
+        Returns the created ticket object (as returned by Autotask).
+        """
+        if not isinstance(payload, dict) or not payload:
+            raise AutotaskError("Ticket payload is empty.")
+
+        data = self._request("POST", "Tickets", json_body=payload)
+        # Autotask commonly returns the created object or an items list.
+        if isinstance(data, dict):
+            if "item" in data and isinstance(data.get("item"), dict):
+                return data["item"]
+            if "items" in data and isinstance(data.get("items"), list) and data.get("items"):
+                first = data.get("items")[0]
+                if isinstance(first, dict):
+                    return first
+            if "id" in data:
+                return data
+        # Fallback: return normalized first item if possible
+        items = self._as_items_list(data)
+        if items:
+            return items[0]
+
+        raise AutotaskError("Autotask did not return a created ticket object.")
diff --git a/containers/backupchecks/src/backend/app/main/routes_run_checks.py b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
index b073af2..b66350c 100644
--- a/containers/backupchecks/src/backend/app/main/routes_run_checks.py
+++ b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
@@ -4,7 +4,8 @@ import calendar
 
 from datetime import date, datetime, time, timedelta, timezone
 
-from flask import jsonify, render_template, request
+from flask import jsonify, render_template, request, url_for
+from urllib.parse import urljoin
 from flask_login import current_user, login_required
 from sqlalchemy import and_, or_, func, text
 
@@ -35,6 +36,106 @@ from ..models import (
     User,
 )
 
+
+def _build_autotask_client_from_settings():
+    """Build an AutotaskClient from stored settings or raise a user-safe exception."""
+    settings = _get_or_create_settings()
+    if not getattr(settings, "autotask_enabled", False):
+        raise RuntimeError("Autotask integration is disabled.")
+
+    required = [
+        getattr(settings, "autotask_environment", None),
+        getattr(settings, "autotask_api_username", None),
+        getattr(settings, "autotask_api_password", None),
+        getattr(settings, "autotask_tracking_identifier", None),
+    ]
+    if any(not (x and str(x).strip()) for x in required):
+        raise RuntimeError("Autotask settings incomplete.")
+
+    from ..integrations.autotask.client import AutotaskClient
+
+    return AutotaskClient(
+        username=settings.autotask_api_username,
+        password=settings.autotask_api_password,
+        api_integration_code=settings.autotask_tracking_identifier,
+        environment=settings.autotask_environment,
+    )
+
+
+def _determine_autotask_severity(status_text: str | None) -> str:
+    s = (status_text or "").strip().lower()
+    if "warning" in s:
+        return "warning"
+    if "error" in s or "fail" in s:
+        return "error"
+    if "missed" in s:
+        return "error"
+    return "warning"
+
+
+def _compose_autotask_ticket_description(
+    *,
+    settings,
+    job: Job,
+    run: JobRun,
+    status_display: str,
+    overall_message: str,
+    objects_payload: list[dict[str, str]],
+) -> str:
+    tz_name = _get_ui_timezone_name() or "Europe/Amsterdam"
+    run_dt = run.run_at
+    run_at_str = _format_datetime(run_dt) if run_dt else "-"
+
+    base_url = (getattr(settings, "autotask_base_url", None) or "").strip()
+    job_rel = url_for("main.job_detail", job_id=job.id)
+    # Link to Job Details with a hint for the specific run.
+    job_link = urljoin(base_url.rstrip("/") + "/", job_rel.lstrip("/"))
+    if run.id:
+        job_link = f"{job_link}?run_id={int(run.id)}"
+
+    lines: list[str] = []
+    lines.append(f"Customer: {job.customer.name if job.customer else ''}")
+    lines.append(f"Job: {job.job_name or ''}")
+    lines.append(f"Backup: {job.backup_software or ''} / {job.backup_type or ''}")
+    lines.append(f"Run at ({tz_name}): {run_at_str}")
+    lines.append(f"Status: {status_display or ''}")
+    lines.append("")
+
+    overall_message = (overall_message or "").strip()
+    if overall_message:
+        lines.append("Summary:")
+        lines.append(overall_message)
+        lines.append("")
+        lines.append("Multiple objects reported messages. See Backupchecks for full details.")
+    else:
+        # Fallback to object-level messages with a hard limit.
+        limit = 10
+        shown = 0
+        total = 0
+        for o in objects_payload or []:
+            name = (o.get("name") or "").strip()
+            err = (o.get("error_message") or "").strip()
+            st = (o.get("status") or "").strip()
+            if not name:
+                continue
+            if not err and not st:
+                continue
+            total += 1
+            if shown >= limit:
+                continue
+            msg = err or st
+            lines.append(f"- {name}: {msg}")
+            shown += 1
+
+        if total == 0:
+            lines.append("No detailed object messages available. See Backupchecks for full details.")
+        elif total > shown:
+            lines.append(f"And {int(total - shown)} additional objects reported similar messages.")
+
+    lines.append("")
+    lines.append(f"Backupchecks details: {job_link}")
+    return "\n".join(lines).strip() + "\n"
+
 # Grace window for matching real runs to an expected schedule slot.
 # A run within +/- 1 hour of the inferred schedule time counts as fulfilling the slot.
 MISSED_GRACE_WINDOW = timedelta(hours=1)
@@ -753,6 +854,8 @@ def run_checks_details():
                 "mail": mail_meta,
                 "body_html": body_html,
                 "objects": objects_payload,
+                "autotask_ticket_id": getattr(run, "autotask_ticket_id", None),
+                "autotask_ticket_number": getattr(run, "autotask_ticket_number", None) or "",
             }
         )
 
@@ -770,6 +873,175 @@ def run_checks_details():
     return jsonify({"status": "ok", "job": job_payload, "runs": runs_payload})
 
 
+@main_bp.post("/api/run-checks/autotask-ticket")
+@login_required
+@roles_required("admin", "operator")
+def api_run_checks_create_autotask_ticket():
+    """Create an Autotask ticket for a specific run.
+
+    Enforces: exactly one ticket per run.
+    """
+    data = request.get_json(silent=True) or {}
+    try:
+        run_id = int(data.get("run_id") or 0)
+    except Exception:
+        run_id = 0
+
+    if run_id <= 0:
+        return jsonify({"status": "error", "message": "Invalid parameters."}), 400
+
+    run = JobRun.query.get(run_id)
+    if not run:
+        return jsonify({"status": "error", "message": "Run not found."}), 404
+
+    # Idempotent: if already created, return existing linkage.
+    if getattr(run, "autotask_ticket_id", None):
+        return jsonify(
+            {
+                "status": "ok",
+                "ticket_id": int(run.autotask_ticket_id),
+                "ticket_number": getattr(run, "autotask_ticket_number", None) or "",
+                "already_exists": True,
+            }
+        )
+
+    job = Job.query.get(run.job_id)
+    if not job:
+        return jsonify({"status": "error", "message": "Job not found."}), 404
+
+    customer = Customer.query.get(job.customer_id) if getattr(job, "customer_id", None) else None
+    if not customer:
+        return jsonify({"status": "error", "message": "Customer not found."}), 404
+
+    if not getattr(customer, "autotask_company_id", None):
+        return jsonify({"status": "error", "message": "Customer has no Autotask company mapping."}), 400
+
+    if (getattr(customer, "autotask_mapping_status", None) or "").strip().lower() not in ("ok", "renamed"):
+        return jsonify({"status": "error", "message": "Autotask company mapping is not valid."}), 400
+
+    settings = _get_or_create_settings()
+
+    base_url = (getattr(settings, "autotask_base_url", None) or "").strip()
+    if not base_url:
+        return jsonify({"status": "error", "message": "Autotask Base URL is not configured."}), 400
+
+    # Required ticket defaults
+    if not getattr(settings, "autotask_default_queue_id", None):
+        return jsonify({"status": "error", "message": "Autotask default queue is not configured."}), 400
+    if not getattr(settings, "autotask_default_ticket_source_id", None):
+        return jsonify({"status": "error", "message": "Autotask default ticket source is not configured."}), 400
+    if not getattr(settings, "autotask_default_ticket_status", None):
+        return jsonify({"status": "error", "message": "Autotask default ticket status is not configured."}), 400
+
+    # Determine display status (including overrides) for consistent subject/priority mapping.
+    status_display = run.status or "-"
+    try:
+        status_display, _, _, _ov_id, _ov_reason = _apply_overrides_to_run(job, run)
+    except Exception:
+        status_display = run.status or "-"
+
+    severity = _determine_autotask_severity(status_display)
+    priority_id = None
+    if severity == "warning":
+        priority_id = getattr(settings, "autotask_priority_warning", None)
+    else:
+        priority_id = getattr(settings, "autotask_priority_error", None)
+
+    # Load mail + objects for ticket composition.
+    msg = MailMessage.query.get(run.mail_message_id) if run.mail_message_id else None
+    overall_message = (getattr(msg, "overall_message", None) or "") if msg else ""
+
+    objects_payload: list[dict[str, str]] = []
+    try:
+        objs = run.objects.order_by(JobObject.object_name.asc()).all()
+    except Exception:
+        objs = list(run.objects or [])
+    for o in objs or []:
+        objects_payload.append(
+            {
+                "name": getattr(o, "object_name", "") or "",
+                "type": getattr(o, "object_type", "") or "",
+                "status": getattr(o, "status", "") or "",
+                "error_message": getattr(o, "error_message", "") or "",
+            }
+        )
+
+    if (not objects_payload) and msg:
+        try:
+            mos = MailObject.query.filter_by(mail_message_id=msg.id).order_by(MailObject.object_name.asc()).all()
+        except Exception:
+            mos = []
+        for mo in mos or []:
+            objects_payload.append(
+                {
+                    "name": getattr(mo, "object_name", "") or "",
+                    "type": getattr(mo, "object_type", "") or "",
+                    "status": getattr(mo, "status", "") or "",
+                    "error_message": getattr(mo, "error_message", "") or "",
+                }
+            )
+
+    subject = f"[Backupchecks] {customer.name} - {job.job_name or ''} - {status_display}"
+    description = _compose_autotask_ticket_description(
+        settings=settings,
+        job=job,
+        run=run,
+        status_display=status_display,
+        overall_message=overall_message,
+        objects_payload=objects_payload,
+    )
+
+    payload = {
+        "companyID": int(customer.autotask_company_id),
+        "title": subject,
+        "description": description,
+        "queueID": int(settings.autotask_default_queue_id),
+        "source": int(settings.autotask_default_ticket_source_id),
+        "status": int(settings.autotask_default_ticket_status),
+    }
+    if priority_id:
+        payload["priority"] = int(priority_id)
+
+    try:
+        client = _build_autotask_client_from_settings()
+        created = client.create_ticket(payload)
+    except Exception as exc:
+        return jsonify({"status": "error", "message": f"Autotask ticket creation failed: {exc}"}), 400
+
+    ticket_id = created.get("id") if isinstance(created, dict) else None
+    ticket_number = None
+    if isinstance(created, dict):
+        ticket_number = created.get("ticketNumber") or created.get("number") or created.get("ticket_number")
+
+    if not ticket_id:
+        return jsonify({"status": "error", "message": "Autotask did not return a ticket id."}), 400
+
+    try:
+        run.autotask_ticket_id = int(ticket_id)
+    except Exception:
+        run.autotask_ticket_id = None
+
+    run.autotask_ticket_number = (str(ticket_number).strip() if ticket_number is not None else "") or None
+    run.autotask_ticket_created_at = datetime.utcnow()
+    run.autotask_ticket_created_by_user_id = current_user.id
+
+    try:
+        db.session.add(run)
+        db.session.commit()
+    except Exception as exc:
+        db.session.rollback()
+        return jsonify({"status": "error", "message": f"Failed to store ticket reference: {exc}"}), 500
+
+    return jsonify(
+        {
+            "status": "ok",
+            "ticket_id": int(run.autotask_ticket_id) if run.autotask_ticket_id else None,
+            "ticket_number": run.autotask_ticket_number or "",
+            "already_exists": False,
+        }
+    )
+
+
 @main_bp.post("/api/run-checks/mark-reviewed")
 @login_required
 @roles_required("admin", "operator")
diff --git a/containers/backupchecks/src/backend/app/migrations.py b/containers/backupchecks/src/backend/app/migrations.py
index 6c21f5e..03e2eea 100644
--- a/containers/backupchecks/src/backend/app/migrations.py
+++ b/containers/backupchecks/src/backend/app/migrations.py
@@ -897,6 +897,7 @@ def run_migrations() -> None:
     migrate_overrides_match_columns()
     migrate_job_runs_review_tracking()
     migrate_job_runs_override_metadata()
+    migrate_job_runs_autotask_ticket_fields()
     migrate_jobs_archiving()
     migrate_news_tables()
     migrate_reporting_tables()
@@ -904,6 +905,67 @@ def run_migrations() -> None:
     print("[migrations] All migrations completed.")
 
 
+def migrate_job_runs_autotask_ticket_fields() -> None:
+    """Add Autotask ticket linkage fields to job_runs if missing.
+
+    Columns:
+    - job_runs.autotask_ticket_id (INTEGER NULL)
+    - job_runs.autotask_ticket_number (VARCHAR(64) NULL)
+    - job_runs.autotask_ticket_created_at (TIMESTAMP NULL)
+    - job_runs.autotask_ticket_created_by_user_id (INTEGER NULL, FK users.id)
+    """
+
+    table = "job_runs"
+    try:
+        engine = db.get_engine()
+    except Exception as exc:
+        print(f"[migrations] Could not get engine for job_runs Autotask ticket migration: {exc}")
+        return
+
+    try:
+        with engine.connect() as conn:
+            cols = _get_table_columns(conn, table)
+            if not cols:
+                return
+
+            if "autotask_ticket_id" not in cols:
+                print("[migrations] Adding job_runs.autotask_ticket_id column...")
+                conn.execute(text('ALTER TABLE "job_runs" ADD COLUMN autotask_ticket_id INTEGER'))
+
+            if "autotask_ticket_number" not in cols:
+                print("[migrations] Adding job_runs.autotask_ticket_number column...")
+                conn.execute(text('ALTER TABLE "job_runs" ADD COLUMN autotask_ticket_number VARCHAR(64)'))
+
+            if "autotask_ticket_created_at" not in cols:
+                print("[migrations] Adding job_runs.autotask_ticket_created_at column...")
+                conn.execute(text('ALTER TABLE "job_runs" ADD COLUMN autotask_ticket_created_at TIMESTAMP'))
+
+            if "autotask_ticket_created_by_user_id" not in cols:
+                print("[migrations] Adding job_runs.autotask_ticket_created_by_user_id column...")
+                conn.execute(text('ALTER TABLE "job_runs" ADD COLUMN autotask_ticket_created_by_user_id INTEGER'))
+
+                try:
+                    conn.execute(
+                        text(
+                            'ALTER TABLE "job_runs" '
+                            'ADD CONSTRAINT job_runs_autotask_ticket_created_by_user_id_fkey '
+                            'FOREIGN KEY (autotask_ticket_created_by_user_id) REFERENCES users(id) '
+                            'ON DELETE SET NULL'
+                        )
+                    )
+                except Exception as exc:
+                    print(
+                        f"[migrations] Could not add FK job_runs.autotask_ticket_created_by_user_id -> users.id (continuing): {exc}"
+                    )
+
+            conn.execute(text('CREATE INDEX IF NOT EXISTS idx_job_runs_autotask_ticket_id ON "job_runs" (autotask_ticket_id)'))
+    except Exception as exc:
+        print(f"[migrations] job_runs table not found; skipping migrate_job_runs_autotask_ticket_fields: {exc}")
+        return
+
+    print("[migrations] migrate_job_runs_autotask_ticket_fields completed.")
+
+
 def migrate_jobs_archiving() -> None:
     """Add archiving columns to jobs if missing.
 
diff --git a/containers/backupchecks/src/backend/app/models.py b/containers/backupchecks/src/backend/app/models.py
index e72a846..3b3d41b 100644
--- a/containers/backupchecks/src/backend/app/models.py
+++ b/containers/backupchecks/src/backend/app/models.py
@@ -275,6 +275,12 @@ class JobRun(db.Model):
     reviewed_at = db.Column(db.DateTime, nullable=True)
     reviewed_by_user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=True)
 
+    # Autotask integration (Phase 4: ticket creation from Run Checks)
+    autotask_ticket_id = db.Column(db.Integer, nullable=True)
+    autotask_ticket_number = db.Column(db.String(64), nullable=True)
+    autotask_ticket_created_at = db.Column(db.DateTime, nullable=True)
+    autotask_ticket_created_by_user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=True)
+
 
     created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
     updated_at = db.Column(
@@ -288,6 +294,8 @@ class JobRun(db.Model):
 
     reviewed_by = db.relationship("User", foreign_keys=[reviewed_by_user_id])
 
+    autotask_ticket_created_by = db.relationship("User", foreign_keys=[autotask_ticket_created_by_user_id])
+
 
 class JobRunReviewEvent(db.Model):
     __tablename__ = "job_run_review_events"
diff --git a/containers/backupchecks/src/templates/main/run_checks.html b/containers/backupchecks/src/templates/main/run_checks.html
index 90de7aa..4701bb2 100644
--- a/containers/backupchecks/src/templates/main/run_checks.html
+++ b/containers/backupchecks/src/templates/main/run_checks.html
@@ -214,18 +214,16 @@
                   <div id="rcm_alerts" class="small"></div>
                   <div class="mt-2">
                     <div class="row g-2 align-items-start">
-                      <div class="col-12 col-lg-6">
-                        <div class="border rounded p-2">
-                          <div class="d-flex align-items-center justify-content-between">
-                            <div class="fw-semibold">New ticket</div>
-                            <button type="button" class="btn btn-sm btn-outline-primary" id="rcm_ticket_save">Add</button>
-                          </div>
-                          <div class="mt-2">
-                            <input class="form-control form-control-sm" id="rcm_ticket_code" type="text" placeholder="Ticket number (e.g., T20260106.0001)" />
-                            </div>
-<div class="mt-2 small text-muted" id="rcm_ticket_status"></div>
-                        </div>
-                      </div>
+	                      <div class="col-12 col-lg-6">
+	                        <div class="border rounded p-2">
+	                          <div class="d-flex align-items-center justify-content-between">
+	                            <div class="fw-semibold">Autotask ticket</div>
+	                            <button type="button" class="btn btn-sm btn-outline-primary" id="rcm_autotask_create">Create</button>
+	                          </div>
+	                          <div class="mt-2 small" id="rcm_autotask_info"></div>
+	                          <div class="mt-2 small text-muted" id="rcm_autotask_status"></div>
+	                        </div>
+	                      </div>
                       <div class="col-12 col-lg-6">
                         <div class="border rounded p-2">
                           <div class="d-flex align-items-center justify-content-between">
@@ -841,56 +839,78 @@ table.addEventListener('change', function (e) {
     }
 
     function bindInlineCreateForms() {
-      var btnTicket = document.getElementById('rcm_ticket_save');
+      var btnAutotask = document.getElementById('rcm_autotask_create');
+      var atInfo = document.getElementById('rcm_autotask_info');
+      var atStatus = document.getElementById('rcm_autotask_status');
+
       var btnRemark = document.getElementById('rcm_remark_save');
-      var tCode = document.getElementById('rcm_ticket_code');
-var tStatus = document.getElementById('rcm_ticket_status');
       var rBody = document.getElementById('rcm_remark_body');
       var rStatus = document.getElementById('rcm_remark_status');
 
       function clearStatus() {
-        if (tStatus) tStatus.textContent = '';
+        if (atStatus) atStatus.textContent = '';
         if (rStatus) rStatus.textContent = '';
       }
 
       function setDisabled(disabled) {
-        if (btnTicket) btnTicket.disabled = disabled;
+        if (btnAutotask) btnAutotask.disabled = disabled;
         if (btnRemark) btnRemark.disabled = disabled;
-        if (tCode) tCode.disabled = disabled;
-if (rBody) rBody.disabled = disabled;
+        if (rBody) rBody.disabled = disabled;
       }
 
       window.__rcmSetCreateDisabled = setDisabled;
       window.__rcmClearCreateStatus = clearStatus;
 
-      if (btnTicket) {
-        btnTicket.addEventListener('click', function () {
+      function renderAutotaskInfo(run) {
+        if (!atInfo) return;
+        var num = (run && run.autotask_ticket_number) ? String(run.autotask_ticket_number) : '';
+        if (num) {
+          atInfo.innerHTML = '<div><strong>Ticket:</strong> ' + escapeHtml(num) + '</div>';
+        } else if (run && run.autotask_ticket_id) {
+          atInfo.innerHTML = '<div><strong>Ticket:</strong> created</div>';
+        } else {
+          atInfo.innerHTML = '<div class="text-muted">No Autotask ticket created for this run.</div>';
+        }
+      }
+      window.__rcmRenderAutotaskInfo = renderAutotaskInfo;
+
+      if (btnAutotask) {
+        btnAutotask.addEventListener('click', function () {
           if (!currentRunId) { alert('Select a run first.'); return; }
           clearStatus();
-          var ticket_code = tCode ? (tCode.value || '').trim().toUpperCase() : '';
-if (!ticket_code) {
-            if (tStatus) tStatus.textContent = 'Ticket number is required.';
-            else alert('Ticket number is required.');
-            return;
-          }
-          if (!/^T\d{8}\.\d{4}$/.test(ticket_code)) {
-            if (tStatus) tStatus.textContent = 'Invalid ticket number format. Expected TYYYYMMDD.####.';
-            else alert('Invalid ticket number format. Expected TYYYYMMDD.####.');
-            return;
-          }
-          if (tStatus) tStatus.textContent = 'Saving...';
-          apiJson('/api/tickets', {
+          if (atStatus) atStatus.textContent = 'Creating ticket...';
+          btnAutotask.disabled = true;
+          apiJson('/api/run-checks/autotask-ticket', {
             method: 'POST',
-            body: JSON.stringify({job_run_id: currentRunId, ticket_code: ticket_code})
+            body: JSON.stringify({run_id: currentRunId})
           })
-          .then(function () {
-            if (tCode) tCode.value = '';
-if (tStatus) tStatus.textContent = '';
-            loadAlerts(currentRunId);
+          .then(function (j) {
+            if (!j || j.status !== 'ok') throw new Error((j && j.message) || 'Failed.');
+            if (atStatus) atStatus.textContent = '';
+
+            // Refresh modal data so UI reflects stored ticket linkage.
+            var keepRunId = currentRunId;
+            if (currentJobId) {
+              return fetch('/api/run-checks/details?job_id=' + encodeURIComponent(currentJobId))
+                .then(function (r) { return r.json(); })
+                .then(function (payload) {
+                  currentPayload = payload;
+                  // Find the same run index
+                  var idx = 0;
+                  var runs = (payload && payload.runs) || [];
+                  for (var i = 0; i < runs.length; i++) {
+                    if (String(runs[i].id) === String(keepRunId)) { idx = i; break; }
+                  }
+                  renderModal(payload, idx);
+                });
+            }
           })
           .catch(function (e) {
-            if (tStatus) tStatus.textContent = e.message || 'Failed.';
+            if (atStatus) atStatus.textContent = e.message || 'Failed.';
             else alert(e.message || 'Failed.');
+          })
+          .finally(function () {
+            // State will be recalculated by renderModal/renderRun.
           });
         });
       }
@@ -956,7 +976,8 @@ if (tStatus) tStatus.textContent = '';
 
       currentRunId = run.id || null;
       if (window.__rcmClearCreateStatus) window.__rcmClearCreateStatus();
-      if (window.__rcmSetCreateDisabled) window.__rcmSetCreateDisabled(!currentRunId);
+      if (window.__rcmRenderAutotaskInfo) window.__rcmRenderAutotaskInfo(run);
+      if (window.__rcmSetCreateDisabled) window.__rcmSetCreateDisabled(!currentRunId || !!run.autotask_ticket_id);
       if (btnMarkSuccessOverride) {
         var _rs = (run.status || '').toString().toLowerCase();
         var _canOverride = !!currentRunId && !run.missed && (_rs.indexOf('override') === -1) && (_rs.indexOf('success') === -1);
@@ -1144,9 +1165,10 @@ if (tStatus) tStatus.textContent = '';
             var dot = run.missed ? "dot-missed" : statusDotClass(run.status);
             var dotHtml = dot ? ('<span class="status-dot ' + dot + ' me-2" aria-hidden="true"></span>') : '';
             var reviewedMark = run.is_reviewed ? ' <span class="ms-2" title="Reviewed" aria-label="Reviewed">✔</span>' : '';
+            var ticketMark = run.autotask_ticket_id ? ' <span class="ms-2" title="Autotask ticket created" aria-label="Autotask ticket">🎫</span>' : '';
 
             a.title = run.status || '';
-            a.innerHTML = dotHtml + '<span class="text-nowrap">' + escapeHtml(run.run_at || 'Run') + '</span>' + reviewedMark;
+            a.innerHTML = dotHtml + '<span class="text-nowrap">' + escapeHtml(run.run_at || 'Run') + '</span>' + reviewedMark + ticketMark;
             a.addEventListener('click', function (ev) {
               ev.preventDefault();
               renderRun(data, idx);

From afd45cc568fa52dbe5e53c1e69221ee8e34ad82b Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Thu, 15 Jan 2026 15:19:37 +0100
Subject: [PATCH 16/63] Auto-commit local changes before build (2026-01-15
 15:19:37)

---
 .last-branch                                  |  2 +-
 .../src/backend/app/migrations.py             | 36 ++++++++++++++++---
 docs/changelog.md                             |  7 ++++
 3 files changed, 40 insertions(+), 5 deletions(-)

diff --git a/.last-branch b/.last-branch
index 4c130c6..76e3ecb 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260115-13-autotask-runchecks-create-ticket
+v20260115-14-autotask-runchecks-ticket-migration-fix
diff --git a/containers/backupchecks/src/backend/app/migrations.py b/containers/backupchecks/src/backend/app/migrations.py
index 03e2eea..f7708dc 100644
--- a/containers/backupchecks/src/backend/app/migrations.py
+++ b/containers/backupchecks/src/backend/app/migrations.py
@@ -3,6 +3,31 @@ from sqlalchemy import inspect, text
 from .database import db
 
 
+def _get_table_columns(conn, table_name: str) -> set[str]:
+    """Return a set of column names for a table using the provided connection.
+
+    Returns an empty set when the table does not exist or cannot be inspected.
+
+    Using information_schema keeps this helper stable across SQLAlchemy
+    versions and avoids creating nested connections while inside begin() blocks.
+    """
+
+    try:
+        result = conn.execute(
+            text(
+                """
+                SELECT column_name
+                FROM information_schema.columns
+                WHERE table_name = :table
+                """
+            ),
+            {"table": table_name},
+        )
+        return {row[0] for row in result.fetchall()}
+    except Exception:
+        return set()
+
+
 def _column_exists(table_name: str, column_name: str) -> bool:
     """Return True if the given column exists on the given table."""
     engine = db.get_engine()
@@ -923,9 +948,10 @@ def migrate_job_runs_autotask_ticket_fields() -> None:
         return
 
     try:
-        with engine.connect() as conn:
+        with engine.begin() as conn:
             cols = _get_table_columns(conn, table)
             if not cols:
+                print("[migrations] job_runs table not found; skipping migrate_job_runs_autotask_ticket_fields")
                 return
 
             if "autotask_ticket_id" not in cols:
@@ -955,12 +981,14 @@ def migrate_job_runs_autotask_ticket_fields() -> None:
                     )
                 except Exception as exc:
                     print(
-                        f"[migrations] Could not add FK job_runs.autotask_ticket_created_by_user_id -> users.id (continuing): {exc}"
+                        f"[migrations] Could not add FK job_runs_autotask_ticket_created_by_user_id -> users.id (continuing): {exc}"
                     )
 
-            conn.execute(text('CREATE INDEX IF NOT EXISTS idx_job_runs_autotask_ticket_id ON "job_runs" (autotask_ticket_id)'))
+            conn.execute(
+                text('CREATE INDEX IF NOT EXISTS idx_job_runs_autotask_ticket_id ON "job_runs" (autotask_ticket_id)')
+            )
     except Exception as exc:
-        print(f"[migrations] job_runs table not found; skipping migrate_job_runs_autotask_ticket_fields: {exc}")
+        print(f"[migrations] migrate_job_runs_autotask_ticket_fields failed (continuing): {exc}")
         return
 
     print("[migrations] migrate_job_runs_autotask_ticket_fields completed.")
diff --git a/docs/changelog.md b/docs/changelog.md
index 454b22e..7ebe7ae 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -100,6 +100,13 @@ Changes:
 - Implemented a new backend endpoint to refresh mapping status for all customers with an Autotask Company ID and return a status summary (ok/renamed/missing/invalid).
 - Updated the Customers UI to call the refresh-all endpoint, show a short result summary, and reload to reflect updated mapping states.
 
+## v20260115-14-autotask-runchecks-ticket-migration-fix
+
+- Fixed missing database helper used by the Autotask ticket fields migration for job runs.
+- Corrected the job_runs migration to ensure Autotask ticket columns are created reliably and committed properly.
+- Resolved Run Checks errors caused by incomplete database migrations after introducing Autotask ticket support.
+
+
 ***
 
 ## v0.1.21

From 473044bd67dfa99da291851bc5a8e81371fbf17d Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Thu, 15 Jan 2026 16:02:52 +0100
Subject: [PATCH 17/63] Auto-commit local changes before build (2026-01-15
 16:02:52)

---
 .last-branch                                  |  2 +-
 .../app/integrations/autotask/client.py       |  7 ++++
 .../src/backend/app/main/routes_settings.py   | 14 ++++++-
 .../src/backend/app/migrations.py             | 37 +++----------------
 .../backupchecks/src/backend/app/models.py    |  1 +
 .../src/templates/main/settings.html          | 14 ++++++-
 docs/changelog.md                             |  5 +++
 7 files changed, 44 insertions(+), 36 deletions(-)

diff --git a/.last-branch b/.last-branch
index 76e3ecb..a30bfd0 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260115-14-autotask-runchecks-ticket-migration-fix
+v20260115-15-autotask-default-ticket-status-setting
diff --git a/containers/backupchecks/src/backend/app/integrations/autotask/client.py b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
index 4989ec1..59a62f0 100644
--- a/containers/backupchecks/src/backend/app/integrations/autotask/client.py
+++ b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
@@ -397,6 +397,13 @@ class AutotaskClient:
 
         return self._call_picklist_values(picklist_values)
 
+    def get_ticket_statuses(self) -> List[Dict[str, Any]]:
+        """Return Ticket Status picklist values.
+
+        We retrieve this from Tickets field metadata to avoid hardcoded status IDs.
+        """
+        return self._get_ticket_picklist_values(field_names=["status", "statusid"])
+
     def create_ticket(self, payload: Dict[str, Any]) -> Dict[str, Any]:
         """Create a Ticket in Autotask.
 
diff --git a/containers/backupchecks/src/backend/app/main/routes_settings.py b/containers/backupchecks/src/backend/app/main/routes_settings.py
index 5897121..2160fb5 100644
--- a/containers/backupchecks/src/backend/app/main/routes_settings.py
+++ b/containers/backupchecks/src/backend/app/main/routes_settings.py
@@ -657,6 +657,7 @@ def settings():
     autotask_queues = []
     autotask_ticket_sources = []
     autotask_priorities = []
+    autotask_ticket_statuses = []
     autotask_last_sync_at = getattr(settings, "autotask_reference_last_sync_at", None)
 
     try:
@@ -677,6 +678,12 @@ def settings():
     except Exception:
         autotask_priorities = []
 
+    try:
+        if getattr(settings, "autotask_cached_ticket_statuses_json", None):
+            autotask_ticket_statuses = json.loads(settings.autotask_cached_ticket_statuses_json) or []
+    except Exception:
+        autotask_ticket_statuses = []
+
     return render_template(
         "main/settings.html",
         settings=settings,
@@ -692,6 +699,7 @@ def settings():
         autotask_queues=autotask_queues,
         autotask_ticket_sources=autotask_ticket_sources,
         autotask_priorities=autotask_priorities,
+        autotask_ticket_statuses=autotask_ticket_statuses,
         autotask_last_sync_at=autotask_last_sync_at,
         news_admin_items=news_admin_items,
         news_admin_stats=news_admin_stats,
@@ -1322,6 +1330,7 @@ def settings_autotask_refresh_reference_data():
         queues = client.get_queues()
         sources = client.get_ticket_sources()
         priorities = client.get_ticket_priorities()
+        statuses = client.get_ticket_statuses()
 
         # Store a minimal subset for dropdowns (id + name/label)
         # Note: Some "reference" values are exposed as picklists (value/label)
@@ -1354,6 +1363,7 @@ def settings_autotask_refresh_reference_data():
 
         settings.autotask_cached_queues_json = json.dumps(_norm(queues))
         settings.autotask_cached_ticket_sources_json = json.dumps(_norm(sources))
+        settings.autotask_cached_ticket_statuses_json = json.dumps(_norm(statuses))
 
         # Priorities are returned as picklist values (value/label)
         pr_out = []
@@ -1377,13 +1387,13 @@ def settings_autotask_refresh_reference_data():
         db.session.commit()
 
         flash(
-            f"Autotask reference data refreshed. Queues: {len(queues)}. Ticket Sources: {len(sources)}. Priorities: {len(pr_out)}.",
+            f"Autotask reference data refreshed. Queues: {len(queues)}. Ticket Sources: {len(sources)}. Ticket Statuses: {len(statuses)}. Priorities: {len(pr_out)}.",
             "success",
         )
         _log_admin_event(
             "autotask_refresh_reference_data",
             "Autotask reference data refreshed.",
-            details=json.dumps({"queues": len(queues or []), "ticket_sources": len(sources or []), "priorities": len(pr_out)}),
+            details=json.dumps({"queues": len(queues or []), "ticket_sources": len(sources or []), "ticket_statuses": len(statuses or []), "priorities": len(pr_out)}),
         )
     except Exception as exc:
         flash(f"Failed to refresh Autotask reference data: {exc}", "danger")
diff --git a/containers/backupchecks/src/backend/app/migrations.py b/containers/backupchecks/src/backend/app/migrations.py
index f7708dc..b1d1405 100644
--- a/containers/backupchecks/src/backend/app/migrations.py
+++ b/containers/backupchecks/src/backend/app/migrations.py
@@ -3,31 +3,6 @@ from sqlalchemy import inspect, text
 from .database import db
 
 
-def _get_table_columns(conn, table_name: str) -> set[str]:
-    """Return a set of column names for a table using the provided connection.
-
-    Returns an empty set when the table does not exist or cannot be inspected.
-
-    Using information_schema keeps this helper stable across SQLAlchemy
-    versions and avoids creating nested connections while inside begin() blocks.
-    """
-
-    try:
-        result = conn.execute(
-            text(
-                """
-                SELECT column_name
-                FROM information_schema.columns
-                WHERE table_name = :table
-                """
-            ),
-            {"table": table_name},
-        )
-        return {row[0] for row in result.fetchall()}
-    except Exception:
-        return set()
-
-
 def _column_exists(table_name: str, column_name: str) -> bool:
     """Return True if the given column exists on the given table."""
     engine = db.get_engine()
@@ -193,6 +168,7 @@ def migrate_system_settings_autotask_integration() -> None:
         ("autotask_cached_queues_json", "TEXT NULL"),
         ("autotask_cached_ticket_sources_json", "TEXT NULL"),
         ("autotask_cached_priorities_json", "TEXT NULL"),
+        ("autotask_cached_ticket_statuses_json", "TEXT NULL"),
         ("autotask_reference_last_sync_at", "TIMESTAMP NULL"),
     ]
 
@@ -948,10 +924,9 @@ def migrate_job_runs_autotask_ticket_fields() -> None:
         return
 
     try:
-        with engine.begin() as conn:
+        with engine.connect() as conn:
             cols = _get_table_columns(conn, table)
             if not cols:
-                print("[migrations] job_runs table not found; skipping migrate_job_runs_autotask_ticket_fields")
                 return
 
             if "autotask_ticket_id" not in cols:
@@ -981,14 +956,12 @@ def migrate_job_runs_autotask_ticket_fields() -> None:
                     )
                 except Exception as exc:
                     print(
-                        f"[migrations] Could not add FK job_runs_autotask_ticket_created_by_user_id -> users.id (continuing): {exc}"
+                        f"[migrations] Could not add FK job_runs.autotask_ticket_created_by_user_id -> users.id (continuing): {exc}"
                     )
 
-            conn.execute(
-                text('CREATE INDEX IF NOT EXISTS idx_job_runs_autotask_ticket_id ON "job_runs" (autotask_ticket_id)')
-            )
+            conn.execute(text('CREATE INDEX IF NOT EXISTS idx_job_runs_autotask_ticket_id ON "job_runs" (autotask_ticket_id)'))
     except Exception as exc:
-        print(f"[migrations] migrate_job_runs_autotask_ticket_fields failed (continuing): {exc}")
+        print(f"[migrations] job_runs table not found; skipping migrate_job_runs_autotask_ticket_fields: {exc}")
         return
 
     print("[migrations] migrate_job_runs_autotask_ticket_fields completed.")
diff --git a/containers/backupchecks/src/backend/app/models.py b/containers/backupchecks/src/backend/app/models.py
index 3b3d41b..4ecba7d 100644
--- a/containers/backupchecks/src/backend/app/models.py
+++ b/containers/backupchecks/src/backend/app/models.py
@@ -127,6 +127,7 @@ class SystemSettings(db.Model):
     autotask_cached_queues_json = db.Column(db.Text, nullable=True)
     autotask_cached_ticket_sources_json = db.Column(db.Text, nullable=True)
     autotask_cached_priorities_json = db.Column(db.Text, nullable=True)
+    autotask_cached_ticket_statuses_json = db.Column(db.Text, nullable=True)
     autotask_reference_last_sync_at = db.Column(db.DateTime, nullable=True)
     created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
     updated_at = db.Column(
diff --git a/containers/backupchecks/src/templates/main/settings.html b/containers/backupchecks/src/templates/main/settings.html
index 6c52acb..3b848e0 100644
--- a/containers/backupchecks/src/templates/main/settings.html
+++ b/containers/backupchecks/src/templates/main/settings.html
@@ -397,6 +397,17 @@
           <div class="form-text">Requires refreshed reference data.</div>
         </div>
 
+        <div class="col-md-6">
+          <label for="autotask_default_ticket_status" class="form-label">Default Ticket Status</label>
+          <select class="form-select" id="autotask_default_ticket_status" name="autotask_default_ticket_status">
+            <option value="" {% if not settings.autotask_default_ticket_status %}selected{% endif %}>Select...</option>
+            {% for st in autotask_ticket_statuses %}
+              <option value="{{ st.id }}" {% if settings.autotask_default_ticket_status == st.id %}selected{% endif %}>{{ st.name }}</option>
+            {% endfor %}
+          </select>
+          <div class="form-text">Required for Autotask ticket creation. Requires refreshed reference data.</div>
+        </div>
+
         <div class="col-md-6">
           <label for="autotask_priority_warning" class="form-label">Priority for Warning</label>
           <select class="form-select" id="autotask_priority_warning" name="autotask_priority_warning">
@@ -444,6 +455,7 @@
         <div class="text-muted small mt-2">
           Cached Queues: {{ autotask_queues|length }}<br />
           Cached Ticket Sources: {{ autotask_ticket_sources|length }}<br />
+          Cached Ticket Statuses: {{ autotask_ticket_statuses|length }}<br />
           Cached Priorities: {{ autotask_priorities|length }}
         </div>
       </div>
@@ -456,7 +468,7 @@
             <button type="submit" class="btn btn-outline-primary">Refresh reference data</button>
           </form>
         </div>
-        <div class="form-text mt-2 text-md-end">Refresh loads Queues, Ticket Sources, and Priorities from Autotask for dropdown usage.</div>
+        <div class="form-text mt-2 text-md-end">Refresh loads Queues, Ticket Sources, Ticket Statuses, and Priorities from Autotask for dropdown usage.</div>
       </div>
     </div>
   </div>
diff --git a/docs/changelog.md b/docs/changelog.md
index 7ebe7ae..d21635a 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -106,6 +106,11 @@ Changes:
 - Corrected the job_runs migration to ensure Autotask ticket columns are created reliably and committed properly.
 - Resolved Run Checks errors caused by incomplete database migrations after introducing Autotask ticket support.
 
+## v20260115-15-autotask-default-ticket-status-setting
+- Added “Default Ticket Status” dropdown to Autotask settings (Ticket defaults).
+- Implemented retrieval and caching of Autotask ticket statuses as reference data for dropdown usage.
+- Extended reference data refresh to include Ticket Statuses and updated diagnostics counters accordingly.
+- Added database column for cached ticket statuses and included it in migrations for existing installations.
 
 ***
 

From 66f5a57fe063e18403ea4c716a4774171d46195f Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Thu, 15 Jan 2026 16:17:26 +0100
Subject: [PATCH 18/63] Auto-commit local changes before build (2026-01-15
 16:17:26)

---
 .last-branch                                  |  2 +-
 .../app/integrations/autotask/client.py       | 93 ++++++++++++++++---
 docs/changelog.md                             |  5 +
 3 files changed, 84 insertions(+), 16 deletions(-)

diff --git a/.last-branch b/.last-branch
index a30bfd0..a340f78 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260115-15-autotask-default-ticket-status-setting
+v20260115-16-autotask-ticket-create-response-fix
diff --git a/containers/backupchecks/src/backend/app/integrations/autotask/client.py b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
index 59a62f0..a9dab64 100644
--- a/containers/backupchecks/src/backend/app/integrations/autotask/client.py
+++ b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
@@ -105,19 +105,20 @@ class AutotaskClient:
             "Accept": "application/json",
         }
 
-    def _request(
+    def _request_raw(
         self,
         method: str,
         path: str,
         params: Optional[Dict[str, Any]] = None,
         json_body: Optional[Dict[str, Any]] = None,
-    ) -> Any:
+    ) -> requests.Response:
+        """Perform an Autotask REST API request and return the raw response."""
         zone = self.get_zone_info()
         base = zone.api_url.rstrip("/")
         url = f"{base}/v1.0/{path.lstrip('/')}"
         headers = self._headers()
 
-        def do_request(use_basic_auth: bool, extra_headers: Optional[Dict[str, str]] = None):
+        def do_request(use_basic_auth: bool, extra_headers: Optional[Dict[str, str]] = None) -> requests.Response:
             h = dict(headers)
             if extra_headers:
                 h.update(extra_headers)
@@ -149,8 +150,7 @@ class AutotaskClient:
             raise AutotaskError(
                 "Authentication failed (HTTP 401). "
                 "Verify API Username, API Secret, and ApiIntegrationCode. "
-                f"Environment={self.environment}, ZoneInfoBase={zi_base}, ZoneApiUrl={zone.api_url}."
-            ,
+                f"Environment={self.environment}, ZoneInfoBase={zi_base}, ZoneApiUrl={zone.api_url}.",
                 status_code=401,
             )
         if resp.status_code == 403:
@@ -163,6 +163,19 @@ class AutotaskClient:
         if resp.status_code >= 400:
             raise AutotaskError(f"Autotask API error (HTTP {resp.status_code}).", status_code=resp.status_code)
 
+        return resp
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        params: Optional[Dict[str, Any]] = None,
+        json_body: Optional[Dict[str, Any]] = None,
+    ) -> Any:
+        resp = self._request_raw(method=method, path=path, params=params, json_body=json_body)
+        if not (resp.content or b""):
+            return {}
+
         try:
             return resp.json()
         except Exception as exc:
@@ -404,6 +417,15 @@ class AutotaskClient:
         """
         return self._get_ticket_picklist_values(field_names=["status", "statusid"])
 
+    def get_ticket(self, ticket_id: int) -> Dict[str, Any]:
+        """Fetch a Ticket by ID via GET /Tickets/<id>."""
+        if not isinstance(ticket_id, int) or ticket_id <= 0:
+            raise AutotaskError("Invalid Autotask ticket id.")
+        data = self._request("GET", f"Tickets/{ticket_id}")
+        if isinstance(data, dict) and data:
+            return data
+        raise AutotaskError("Autotask did not return a ticket object.")
+
     def create_ticket(self, payload: Dict[str, Any]) -> Dict[str, Any]:
         """Create a Ticket in Autotask.
 
@@ -413,20 +435,61 @@ class AutotaskClient:
         if not isinstance(payload, dict) or not payload:
             raise AutotaskError("Ticket payload is empty.")
 
-        data = self._request("POST", "Tickets", json_body=payload)
-        # Autotask commonly returns the created object or an items list.
+        resp = self._request_raw("POST", "Tickets", json_body=payload)
+
+        data: Any = {}
+        if resp.content:
+            try:
+                data = resp.json()
+            except Exception:
+                # Some tenants return an empty body or a non-JSON body on successful POST.
+                data = {}
+
+        ticket_id: Optional[int] = None
+
+        # Autotask may return a lightweight create result like {"itemId": 12345}.
         if isinstance(data, dict):
-            if "item" in data and isinstance(data.get("item"), dict):
-                return data["item"]
-            if "items" in data and isinstance(data.get("items"), list) and data.get("items"):
+            for key in ("itemId", "itemID", "id", "ticketId", "ticketID"):
+                if key in data and str(data.get(key) or "").isdigit():
+                    ticket_id = int(data[key])
+                    break
+
+            # Some variants wrap the created entity.
+            if ticket_id is None and "item" in data and isinstance(data.get("item"), dict):
+                item = data.get("item")
+                if "id" in item and str(item.get("id") or "").isdigit():
+                    ticket_id = int(item["id"])
+                else:
+                    return item
+
+            if ticket_id is None and "items" in data and isinstance(data.get("items"), list) and data.get("items"):
                 first = data.get("items")[0]
                 if isinstance(first, dict):
-                    return first
-            if "id" in data:
-                return data
-        # Fallback: return normalized first item if possible
+                    if "id" in first and str(first.get("id") or "").isdigit():
+                        ticket_id = int(first["id"])
+                    else:
+                        return first
+
+        # Location header often contains the created entity URL.
+        if ticket_id is None:
+            location = (resp.headers.get("Location") or resp.headers.get("location") or "").strip()
+            if location:
+                try:
+                    last = location.rstrip("/").split("/")[-1]
+                    if last.isdigit():
+                        ticket_id = int(last)
+                except Exception:
+                    ticket_id = None
+
+        # If we have an ID, fetch the full ticket object so callers can reliably access ticketNumber etc.
+        if ticket_id is not None:
+            return self.get_ticket(ticket_id)
+
+        # Last-resort fallback: normalize first item if possible.
         items = self._as_items_list(data)
         if items:
             return items[0]
 
-        raise AutotaskError("Autotask did not return a created ticket object.")
+        raise AutotaskError(
+            f"Autotask did not return a created ticket object (HTTP {resp.status_code})."
+        )
diff --git a/docs/changelog.md b/docs/changelog.md
index d21635a..6715874 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -112,6 +112,11 @@ Changes:
 - Extended reference data refresh to include Ticket Statuses and updated diagnostics counters accordingly.
 - Added database column for cached ticket statuses and included it in migrations for existing installations.
 
+## v20260115-16-autotask-ticket-create-response-fix
+- Fixed Autotask ticket creation handling for tenants that return a lightweight or empty POST /Tickets response.
+- Added support for extracting the created ticket ID from itemId/id fields and from the Location header.
+- Added a follow-up GET /Tickets/{id} to always retrieve the full created ticket object (ensuring ticketNumber/id are available).
+
 ***
 
 ## v0.1.21

From 83a29a7a3c80b11db324dbaa79169d4dcaeae20a Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Thu, 15 Jan 2026 16:31:32 +0100
Subject: [PATCH 19/63] Auto-commit local changes before build (2026-01-15
 16:31:32)

---
 .last-branch                                  |  2 +-
 .../app/integrations/autotask/client.py       | 66 ++++++++++++++++++-
 docs/changelog.md                             |  6 ++
 3 files changed, 72 insertions(+), 2 deletions(-)

diff --git a/.last-branch b/.last-branch
index a340f78..800bf22 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260115-16-autotask-ticket-create-response-fix
+v20260115-17-autotask-ticket-create-trackingid-lookup
diff --git a/containers/backupchecks/src/backend/app/integrations/autotask/client.py b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
index a9dab64..847867a 100644
--- a/containers/backupchecks/src/backend/app/integrations/autotask/client.py
+++ b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
@@ -426,6 +426,51 @@ class AutotaskClient:
             return data
         raise AutotaskError("Autotask did not return a ticket object.")
 
+    def _lookup_created_ticket_id(
+        self,
+        tracking_identifier: str,
+        company_id: Optional[int] = None,
+    ) -> Optional[int]:
+        """Lookup the most recently created ticket by tracking identifier.
+
+        Some Autotask tenants return an empty body and omit Location headers on
+        successful POST /Tickets calls. In that case, we must lookup the created
+        ticket deterministically via query.
+
+        We prefer filtering by CompanyID when available to reduce ambiguity.
+        """
+
+        tid = (tracking_identifier or "").strip()
+        if not tid:
+            return None
+
+        filters: List[Dict[str, Any]] = [
+            {"op": "eq", "field": "TrackingIdentifier", "value": tid},
+        ]
+        if isinstance(company_id, int) and company_id > 0:
+            filters.append({"op": "eq", "field": "CompanyID", "value": int(company_id)})
+
+        # Order by createDate desc when supported; fall back to id desc.
+        search_payload: Dict[str, Any] = {
+            "filter": filters,
+            "maxRecords": 1,
+            "orderby": [
+                {"field": "createDate", "direction": "desc"},
+                {"field": "id", "direction": "desc"},
+            ],
+        }
+
+        params = {"search": json.dumps(search_payload)}
+        data = self._request("GET", "Tickets/query", params=params)
+        items = self._as_items_list(data)
+        if not items:
+            return None
+
+        first = items[0]
+        if isinstance(first, dict) and str(first.get("id") or "").isdigit():
+            return int(first["id"])
+        return None
+
     def create_ticket(self, payload: Dict[str, Any]) -> Dict[str, Any]:
         """Create a Ticket in Autotask.
 
@@ -485,11 +530,30 @@ class AutotaskClient:
         if ticket_id is not None:
             return self.get_ticket(ticket_id)
 
+        # Deterministic fallback: query by tracking identifier (+ company) if present.
+        tracking_identifier = (
+            payload.get("trackingIdentifier")
+            or payload.get("TrackingIdentifier")
+            or ""
+        )
+        company_id: Optional[int] = None
+        for ck in ("companyID", "companyId", "CompanyID"):
+            if str(payload.get(ck) or "").isdigit():
+                company_id = int(payload[ck])
+                break
+
+        looked_up_id = self._lookup_created_ticket_id(str(tracking_identifier), company_id=company_id)
+        if looked_up_id is not None:
+            return self.get_ticket(looked_up_id)
+
         # Last-resort fallback: normalize first item if possible.
         items = self._as_items_list(data)
         if items:
             return items[0]
 
         raise AutotaskError(
-            f"Autotask did not return a created ticket object (HTTP {resp.status_code})."
+            "Autotask did not return a ticket id. "
+            "Ticket creation may still have succeeded; configure ticket TrackingIdentifier to be unique per run "
+            "to allow deterministic lookup. "
+            f"(HTTP {resp.status_code})."
         )
diff --git a/docs/changelog.md b/docs/changelog.md
index 6715874..c68b209 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -117,6 +117,12 @@ Changes:
 - Added support for extracting the created ticket ID from itemId/id fields and from the Location header.
 - Added a follow-up GET /Tickets/{id} to always retrieve the full created ticket object (ensuring ticketNumber/id are available).
 
+## v20260115-17-autotask-ticket-create-trackingid-lookup
+- Reworked Autotask ticket creation flow to no longer rely on POST /Tickets response data for returning an ID.
+- Added deterministic fallback lookup using Tickets/query filtered by TrackingIdentifier (and CompanyID when available).
+- Ensured the created ticket is reliably retrieved via follow-up GET /Tickets/{id} so ticketNumber/id can always be stored.
+- Eliminated false-negative ticket creation errors when Autotask returns an empty body and no Location header.
+
 ***
 
 ## v0.1.21

From abb67807442327f3edaeab180e7a28f7c62bf0a3 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Fri, 16 Jan 2026 09:04:12 +0100
Subject: [PATCH 20/63] Auto-commit local changes before build (2026-01-16
 09:04:12)

---
 .last-branch                                  |   2 +-
 .../app/integrations/autotask/client.py       | 117 +++++++++++++++++-
 docs/changelog.md                             |   6 +
 3 files changed, 120 insertions(+), 5 deletions(-)

diff --git a/.last-branch b/.last-branch
index 800bf22..58c7cf5 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260115-17-autotask-ticket-create-trackingid-lookup
+v20260115-19-autotask-ticket-create-debug-logging
diff --git a/containers/backupchecks/src/backend/app/integrations/autotask/client.py b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
index 847867a..0034119 100644
--- a/containers/backupchecks/src/backend/app/integrations/autotask/client.py
+++ b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
@@ -1,10 +1,16 @@
 import json
+import logging
+import os
+import uuid
 from dataclasses import dataclass
 from typing import Any, Dict, List, Optional
 
 import requests
 
 
+logger = logging.getLogger(__name__)
+
+
 @dataclass
 class AutotaskZoneInfo:
     zone_name: str
@@ -37,6 +43,29 @@ class AutotaskClient:
         self._zone_info: Optional[AutotaskZoneInfo] = None
         self._zoneinfo_base_used: Optional[str] = None
 
+    def _debug_enabled(self) -> bool:
+        """Return True when verbose Autotask integration logging is enabled.
+
+        This is intentionally controlled via an environment variable to avoid
+        writing sensitive payloads to logs by default.
+        """
+        return str(os.getenv("BACKUPCHECKS_AUTOTASK_DEBUG", "")).strip().lower() in {
+            "1",
+            "true",
+            "yes",
+            "on",
+        }
+
+    def _safe_json_preview(self, data: Any, max_chars: int = 1200) -> str:
+        """Serialize JSON-like data for logging, truncating large payloads."""
+        try:
+            s = json.dumps(data, ensure_ascii=False, default=str)
+        except Exception:
+            s = str(data)
+        if len(s) > max_chars:
+            return s[:max_chars] + "…"
+        return s
+
     def _zoneinfo_bases(self) -> List[str]:
         """Return a list of zoneInformation base URLs to try.
 
@@ -430,6 +459,7 @@ class AutotaskClient:
         self,
         tracking_identifier: str,
         company_id: Optional[int] = None,
+        corr_id: Optional[str] = None,
     ) -> Optional[int]:
         """Lookup the most recently created ticket by tracking identifier.
 
@@ -461,8 +491,22 @@ class AutotaskClient:
         }
 
         params = {"search": json.dumps(search_payload)}
+        if self._debug_enabled():
+            logger.info(
+                "[autotask][%s] Tickets/query lookup payload=%s",
+                corr_id or "-",
+                self._safe_json_preview(search_payload, max_chars=1200),
+            )
+
         data = self._request("GET", "Tickets/query", params=params)
         items = self._as_items_list(data)
+        if self._debug_enabled():
+            logger.info(
+                "[autotask][%s] Tickets/query lookup result_count=%s keys=%s",
+                corr_id or "-",
+                len(items),
+                (sorted(list(items[0].keys())) if items and isinstance(items[0], dict) else None),
+            )
         if not items:
             return None
 
@@ -480,8 +524,36 @@ class AutotaskClient:
         if not isinstance(payload, dict) or not payload:
             raise AutotaskError("Ticket payload is empty.")
 
+        corr_id = uuid.uuid4().hex[:10]
+
+        if self._debug_enabled():
+            # Avoid dumping full descriptions by default, but include key routing fields.
+            payload_keys = sorted(list(payload.keys()))
+            logger.info(
+                "[autotask][%s] POST /Tickets payload_keys=%s companyID=%s queueID=%s source=%s status=%s priority=%s trackingIdentifier=%s",
+                corr_id,
+                payload_keys,
+                payload.get("companyID") or payload.get("CompanyID") or payload.get("companyId"),
+                payload.get("queueID") or payload.get("QueueID") or payload.get("queueId"),
+                payload.get("source") or payload.get("Source") or payload.get("sourceId") or payload.get("sourceID"),
+                payload.get("status") or payload.get("Status") or payload.get("statusId") or payload.get("statusID"),
+                payload.get("priority") or payload.get("Priority"),
+                payload.get("trackingIdentifier") or payload.get("TrackingIdentifier"),
+            )
+
         resp = self._request_raw("POST", "Tickets", json_body=payload)
 
+        if self._debug_enabled():
+            location = (resp.headers.get("Location") or resp.headers.get("location") or "").strip()
+            logger.info(
+                "[autotask][%s] POST /Tickets response http=%s content_type=%s content_length=%s location=%s",
+                corr_id,
+                resp.status_code,
+                (resp.headers.get("Content-Type") or resp.headers.get("content-type") or ""),
+                (len(resp.content or b"") if resp is not None else None),
+                location or None,
+            )
+
         data: Any = {}
         if resp.content:
             try:
@@ -489,6 +561,25 @@ class AutotaskClient:
             except Exception:
                 # Some tenants return an empty body or a non-JSON body on successful POST.
                 data = {}
+                if self._debug_enabled():
+                    # Log a short preview of the raw body to understand tenant behaviour.
+                    try:
+                        body_preview = (resp.text or "")[:600]
+                    except Exception:
+                        body_preview = ""
+                    logger.info(
+                        "[autotask][%s] POST /Tickets non-JSON body preview=%s",
+                        corr_id,
+                        body_preview,
+                    )
+
+        if self._debug_enabled():
+            logger.info(
+                "[autotask][%s] POST /Tickets parsed_json_type=%s json_preview=%s",
+                corr_id,
+                type(data).__name__,
+                self._safe_json_preview(data, max_chars=1200),
+            )
 
         ticket_id: Optional[int] = None
 
@@ -526,6 +617,13 @@ class AutotaskClient:
                 except Exception:
                     ticket_id = None
 
+        if self._debug_enabled():
+            logger.info(
+                "[autotask][%s] POST /Tickets extracted_ticket_id=%s",
+                corr_id,
+                ticket_id,
+            )
+
         # If we have an ID, fetch the full ticket object so callers can reliably access ticketNumber etc.
         if ticket_id is not None:
             return self.get_ticket(ticket_id)
@@ -542,7 +640,19 @@ class AutotaskClient:
                 company_id = int(payload[ck])
                 break
 
-        looked_up_id = self._lookup_created_ticket_id(str(tracking_identifier), company_id=company_id)
+        if self._debug_enabled():
+            logger.info(
+                "[autotask][%s] fallback lookup by TrackingIdentifier=%s companyID=%s",
+                corr_id,
+                str(tracking_identifier),
+                company_id,
+            )
+
+        looked_up_id = self._lookup_created_ticket_id(
+            str(tracking_identifier),
+            company_id=company_id,
+            corr_id=corr_id,
+        )
         if looked_up_id is not None:
             return self.get_ticket(looked_up_id)
 
@@ -553,7 +663,6 @@ class AutotaskClient:
 
         raise AutotaskError(
             "Autotask did not return a ticket id. "
-            "Ticket creation may still have succeeded; configure ticket TrackingIdentifier to be unique per run "
-            "to allow deterministic lookup. "
-            f"(HTTP {resp.status_code})."
+            "Ticket creation may still have succeeded. "
+            f"(HTTP {resp.status_code}, Correlation={corr_id})."
         )
diff --git a/docs/changelog.md b/docs/changelog.md
index c68b209..e70b3f0 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -123,6 +123,12 @@ Changes:
 - Ensured the created ticket is reliably retrieved via follow-up GET /Tickets/{id} so ticketNumber/id can always be stored.
 - Eliminated false-negative ticket creation errors when Autotask returns an empty body and no Location header.
 
+## v20260115-19-autotask-ticket-create-debug-logging
+- Added optional verbose Autotask ticket creation logging (guarded by BACKUPCHECKS_AUTOTASK_DEBUG=1).
+- Introduced per-request correlation IDs and included them in ticket creation error messages for log tracing.
+- Logged POST /Tickets response characteristics (status, headers, body preview) to diagnose tenants returning incomplete create responses.
+- Logged fallback Tickets/query lookup payload and result shape to pinpoint why deterministic lookup fails.
+
 ***
 
 ## v0.1.21

From 748769afc0feb28bf5497644738aa361b7c46564 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Fri, 16 Jan 2026 10:01:42 +0100
Subject: [PATCH 21/63] Auto-commit local changes before build (2026-01-16
 10:01:42)

---
 .last-branch                                         |  2 +-
 .../src/backend/app/integrations/autotask/client.py  | 12 ++++++++++++
 docs/changelog.md                                    |  9 +++++++++
 3 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/.last-branch b/.last-branch
index 58c7cf5..d9aeb76 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260115-19-autotask-ticket-create-debug-logging
+v20260116-01-autotask-ticket-id-normalization
diff --git a/containers/backupchecks/src/backend/app/integrations/autotask/client.py b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
index 0034119..609dc74 100644
--- a/containers/backupchecks/src/backend/app/integrations/autotask/client.py
+++ b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
@@ -451,7 +451,19 @@ class AutotaskClient:
         if not isinstance(ticket_id, int) or ticket_id <= 0:
             raise AutotaskError("Invalid Autotask ticket id.")
         data = self._request("GET", f"Tickets/{ticket_id}")
+        # Autotask commonly wraps single-entity GET results in an "item" object.
+        # Normalize to the entity dict so callers can access fields like "id" and
+        # "ticketNumber" without having to unwrap.
         if isinstance(data, dict) and data:
+            if isinstance(data.get("item"), dict) and data.get("item"):
+                return data["item"]
+
+            # Some endpoints/tenants may return a list even for a single ID.
+            if isinstance(data.get("items"), list) and data.get("items"):
+                first = data.get("items")[0]
+                if isinstance(first, dict) and first:
+                    return first
+
             return data
         raise AutotaskError("Autotask did not return a ticket object.")
 
diff --git a/docs/changelog.md b/docs/changelog.md
index e70b3f0..ae380bf 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -129,6 +129,15 @@ Changes:
 - Logged POST /Tickets response characteristics (status, headers, body preview) to diagnose tenants returning incomplete create responses.
 - Logged fallback Tickets/query lookup payload and result shape to pinpoint why deterministic lookup fails.
 
+## v20260116-01-autotask-ticket-id-normalization
+
+### Changes:
+- Normalized Autotask GET /Tickets/{id} API responses by unwrapping the returned "item" object.
+- Ensured the ticket data is returned as a flat object so existing logic can reliably read the ticket id.
+- Enabled correct retrieval of the Autotask ticketNumber via a follow-up GET after ticket creation.
+- Prevented false error messages where ticket creation succeeded but no ticket id was detected.
+
+
 ***
 
 ## v0.1.21

From 8a16ff010fd530673377e30918fbfd3b477c8fab Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Fri, 16 Jan 2026 10:07:17 +0100
Subject: [PATCH 22/63] Auto-commit local changes before build (2026-01-16
 10:07:17)

---
 .last-branch                                               | 2 +-
 containers/backupchecks/src/templates/main/run_checks.html | 5 +++--
 docs/changelog.md                                          | 6 ++++++
 3 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/.last-branch b/.last-branch
index d9aeb76..0020da5 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260116-01-autotask-ticket-id-normalization
+v20260116-02-runchecks-autotask-create-refresh
diff --git a/containers/backupchecks/src/templates/main/run_checks.html b/containers/backupchecks/src/templates/main/run_checks.html
index 4701bb2..7cfcd15 100644
--- a/containers/backupchecks/src/templates/main/run_checks.html
+++ b/containers/backupchecks/src/templates/main/run_checks.html
@@ -901,7 +901,8 @@ table.addEventListener('change', function (e) {
                   for (var i = 0; i < runs.length; i++) {
                     if (String(runs[i].id) === String(keepRunId)) { idx = i; break; }
                   }
-                  renderModal(payload, idx);
+                  // Re-render the currently open Run Checks modal with fresh data.
+                  renderRun(payload, idx);
                 });
             }
           })
@@ -910,7 +911,7 @@ table.addEventListener('change', function (e) {
             else alert(e.message || 'Failed.');
           })
           .finally(function () {
-            // State will be recalculated by renderModal/renderRun.
+            // State will be recalculated by renderRun.
           });
         });
       }
diff --git a/docs/changelog.md b/docs/changelog.md
index ae380bf..2bd6da5 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -137,6 +137,12 @@ Changes:
 - Enabled correct retrieval of the Autotask ticketNumber via a follow-up GET after ticket creation.
 - Prevented false error messages where ticket creation succeeded but no ticket id was detected.
 
+## v20260116-02-runchecks-autotask-create-refresh
+
+Changes:
+- Fixed a JavaScript error in the Run Checks view where a non-existent renderModal() function was called after creating an Autotask ticket.
+- Replaced the renderModal() call with renderRun() to properly refresh the Run Checks modal state.
+- Ensured the Autotask ticket status is updated in the UI without throwing a frontend error.
 
 ***
 

From 93990822313546640eae82460e0a661d0b299909 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Fri, 16 Jan 2026 10:29:40 +0100
Subject: [PATCH 23/63] Auto-commit local changes before build (2026-01-16
 10:29:40)

---
 .last-branch                                  |  2 +-
 .../src/backend/app/main/routes_run_checks.py | 72 +++++++++++++++++--
 docs/changelog.md                             | 10 ++-
 3 files changed, 78 insertions(+), 6 deletions(-)

diff --git a/.last-branch b/.last-branch
index 0020da5..fabe856 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260116-02-runchecks-autotask-create-refresh
+v20260116-03-autotask-ticket-linking-visibility
diff --git a/containers/backupchecks/src/backend/app/main/routes_run_checks.py b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
index b66350c..7dc5b83 100644
--- a/containers/backupchecks/src/backend/app/main/routes_run_checks.py
+++ b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
@@ -32,6 +32,9 @@ from ..models import (
     JobRunReviewEvent,
     MailMessage,
     MailObject,
+    Ticket,
+    TicketJobRun,
+    TicketScope,
     Override,
     User,
 )
@@ -1008,23 +1011,84 @@ def api_run_checks_create_autotask_ticket():
     except Exception as exc:
         return jsonify({"status": "error", "message": f"Autotask ticket creation failed: {exc}"}), 400
 
-    ticket_id = created.get("id") if isinstance(created, dict) else None
-    ticket_number = None
+    ticket_id = None
     if isinstance(created, dict):
-        ticket_number = created.get("ticketNumber") or created.get("number") or created.get("ticket_number")
+        ticket_id = created.get("id") or created.get("itemId") or created.get("ticketId")
+        try:
+            # Some wrappers return {"item": {"id": ...}}
+            if not ticket_id and isinstance(created.get("item"), dict):
+                ticket_id = created.get("item", {}).get("id")
+        except Exception:
+            pass
 
     if not ticket_id:
         return jsonify({"status": "error", "message": "Autotask did not return a ticket id."}), 400
 
+    # Autotask typically does not return the ticket number on create.
+    # Always fetch the created ticket so we can persist the ticketNumber for UI and internal linking.
+    ticket_number = None
+    try:
+        fetched = client.get_ticket(int(ticket_id))
+        if isinstance(fetched, dict) and isinstance(fetched.get("item"), dict):
+            fetched = fetched.get("item")
+        if isinstance(fetched, dict):
+            ticket_number = fetched.get("ticketNumber") or fetched.get("number") or fetched.get("ticket_number")
+    except Exception:
+        ticket_number = None
+
     try:
         run.autotask_ticket_id = int(ticket_id)
     except Exception:
         run.autotask_ticket_id = None
 
+    now = datetime.utcnow()
     run.autotask_ticket_number = (str(ticket_number).strip() if ticket_number is not None else "") or None
-    run.autotask_ticket_created_at = datetime.utcnow()
+    run.autotask_ticket_created_at = now
     run.autotask_ticket_created_by_user_id = current_user.id
 
+    # Also store an internal Ticket record and link it to the run.
+    # This keeps Tickets/Remarks, Job Details, and Run Checks indicators consistent with the existing manual workflow.
+    internal_ticket = None
+    if run.autotask_ticket_number:
+        ticket_code = (run.autotask_ticket_number or "").strip().upper()
+        internal_ticket = Ticket.query.filter_by(ticket_code=ticket_code).first()
+        if not internal_ticket:
+            internal_ticket = Ticket(
+                ticket_code=ticket_code,
+                title=subject,
+                description=description,
+                active_from_date=_to_amsterdam_date(run.run_at) or _to_amsterdam_date(now) or now.date(),
+                start_date=now,
+                resolved_at=None,
+            )
+            db.session.add(internal_ticket)
+            db.session.flush()
+
+        # Ensure a job scope exists (used by popups / job details / tickets page)
+        scope = None
+        if job and job.id and internal_ticket and internal_ticket.id:
+            scope = TicketScope.query.filter_by(ticket_id=internal_ticket.id, scope_type="job", job_id=job.id).first()
+        if not scope and internal_ticket and internal_ticket.id:
+            scope = TicketScope(
+                ticket_id=internal_ticket.id,
+                scope_type="job",
+                customer_id=job.customer_id if job else None,
+                backup_software=job.backup_software if job else None,
+                backup_type=job.backup_type if job else None,
+                job_id=job.id if job else None,
+                job_name_match=job.job_name if job else None,
+                job_name_match_mode="exact",
+                resolved_at=None,
+            )
+            db.session.add(scope)
+        elif scope:
+            scope.resolved_at = None
+
+        # Link ticket to this job run (idempotent)
+        if internal_ticket and internal_ticket.id and run.id:
+            if not TicketJobRun.query.filter_by(ticket_id=internal_ticket.id, job_run_id=run.id).first():
+                db.session.add(TicketJobRun(ticket_id=internal_ticket.id, job_run_id=run.id, link_source="autotask"))
+
     try:
         db.session.add(run)
         db.session.commit()
diff --git a/docs/changelog.md b/docs/changelog.md
index 2bd6da5..7c8a16a 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -139,11 +139,19 @@ Changes:
 
 ## v20260116-02-runchecks-autotask-create-refresh
 
-Changes:
+### Changes:
 - Fixed a JavaScript error in the Run Checks view where a non-existent renderModal() function was called after creating an Autotask ticket.
 - Replaced the renderModal() call with renderRun() to properly refresh the Run Checks modal state.
 - Ensured the Autotask ticket status is updated in the UI without throwing a frontend error.
 
+## v20260116-03-autotask-ticket-linking-visibility
+
+### Changes:
+- Ensured Autotask tickets created via Run Checks are stored as internal Ticket records instead of only external references.
+- Linked created Autotask tickets to the corresponding Job Run so they appear in Tickets/Remarks.
+- Added proper ticket association to Job Details, matching the behaviour of manually entered tickets.
+- Updated the Run Checks view to show the ticket indicator when an Autotask ticket is linked to a run.
+
 ***
 
 ## v0.1.21

From b46b7fbc21b03d859177c5c811a4585c3b5e2654 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Fri, 16 Jan 2026 12:28:07 +0100
Subject: [PATCH 24/63] Auto-commit local changes before build (2026-01-16
 12:28:07)

---
 .last-branch                                  |   2 +-
 .../app/integrations/autotask/client.py       | 104 ++++
 .../src/backend/app/main/routes_run_checks.py | 104 ++++
 .../src/templates/main/run_checks.html        |  70 ++-
 ...ation_functional_design_living_document.md | 412 ++++++++++++++++
 ...k_integration_functional_design_phase_1.md | 464 ------------------
 ...task_integration_phase_2_implementation.md | 432 ++++++++++++++++
 docs/changelog.md                             |  11 +
 8 files changed, 1128 insertions(+), 471 deletions(-)
 create mode 100644 docs/backupchecks_autotask_integration_functional_design_living_document.md
 delete mode 100644 docs/backupchecks_autotask_integration_functional_design_phase_1.md
 create mode 100644 docs/backupchecks_autotask_integration_phase_2_implementation.md

diff --git a/.last-branch b/.last-branch
index fabe856..bb1550c 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260116-03-autotask-ticket-linking-visibility
+v20260116-04-runchecks-autotask-ticket-polling
diff --git a/containers/backupchecks/src/backend/app/integrations/autotask/client.py b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
index 609dc74..722955a 100644
--- a/containers/backupchecks/src/backend/app/integrations/autotask/client.py
+++ b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
@@ -467,6 +467,110 @@ class AutotaskClient:
             return data
         raise AutotaskError("Autotask did not return a ticket object.")
 
+    def query_tickets_by_ids(
+        self,
+        ticket_ids: List[int],
+        *,
+        max_records_per_query: int = 200,
+        corr_id: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        """Fetch multiple Tickets by id.
+
+        Preferred path:
+        - Use GET Tickets/query with an 'in' filter over id.
+
+        Fallback path:
+        - If the tenant does not support 'in' queries, fetch tickets individually
+          via GET Tickets/<id>.
+
+        Returns a list of ticket objects (dicts) for tickets that exist.
+        """
+
+        # Normalize ids
+        ids: List[int] = []
+        for x in ticket_ids or []:
+            try:
+                xi = int(x)
+            except Exception:
+                continue
+            if xi > 0:
+                ids.append(xi)
+
+        # De-duplicate while preserving order
+        seen = set()
+        dedup: List[int] = []
+        for xi in ids:
+            if xi in seen:
+                continue
+            seen.add(xi)
+            dedup.append(xi)
+
+        if not dedup:
+            return []
+
+        corr = corr_id or uuid.uuid4().hex[:10]
+
+        def _chunk(lst: List[int], n: int) -> List[List[int]]:
+            return [lst[i : i + n] for i in range(0, len(lst), n)]
+
+        out: List[Dict[str, Any]] = []
+
+        # Try query with op=in first (chunked)
+        try:
+            for chunk in _chunk(dedup, max(1, int(max_records_per_query))):
+                search_payload: Dict[str, Any] = {
+                    "filter": [
+                        {"op": "in", "field": "id", "value": chunk},
+                    ],
+                    "maxRecords": len(chunk),
+                }
+                params = {"search": json.dumps(search_payload)}
+                if self._debug_enabled():
+                    logger.info(
+                        "[autotask][%s] Tickets/query ids payload=%s",
+                        corr,
+                        self._safe_json_preview(search_payload, max_chars=1200),
+                    )
+                data = self._request("GET", "Tickets/query", params=params)
+                items = self._as_items_list(data)
+                for it in items:
+                    if isinstance(it, dict) and it:
+                        out.append(it)
+            return out
+        except AutotaskError as exc:
+            # Common tenant behavior: reject op=in with HTTP 400.
+            if self._debug_enabled():
+                logger.info(
+                    "[autotask][%s] Tickets/query ids op=in failed; falling back to per-ticket GET. error=%s",
+                    corr,
+                    str(exc),
+                )
+        except Exception as exc:
+            if self._debug_enabled():
+                logger.info(
+                    "[autotask][%s] Tickets/query ids unexpected error; falling back. error=%s",
+                    corr,
+                    str(exc),
+                )
+
+        # Fallback: individual GET calls (best-effort)
+        for tid in dedup:
+            try:
+                t = self.get_ticket(int(tid))
+                if isinstance(t, dict) and t:
+                    out.append(t)
+            except AutotaskError as exc:
+                # 404 -> deleted/missing ticket, ignore
+                if getattr(exc, "status_code", None) == 404:
+                    continue
+                # Any other error: continue best-effort
+                continue
+            except Exception:
+                continue
+
+        return out
+
+
     def _lookup_created_ticket_id(
         self,
         tracking_identifier: str,
diff --git a/containers/backupchecks/src/backend/app/main/routes_run_checks.py b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
index 7dc5b83..9b2c06d 100644
--- a/containers/backupchecks/src/backend/app/main/routes_run_checks.py
+++ b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
@@ -876,6 +876,110 @@ def run_checks_details():
     return jsonify({"status": "ok", "job": job_payload, "runs": runs_payload})
 
 
+
+
+@main_bp.get("/api/run-checks/autotask-ticket-poll")
+@login_required
+@roles_required("admin", "operator")
+def api_run_checks_autotask_ticket_poll():
+    """Read-only polling of Autotask ticket state for Run Checks.
+
+    Important:
+    - No Backupchecks state is modified.
+    - No mutations are performed in Autotask.
+    - This endpoint is intended to be called only from the Run Checks page.
+    """
+
+    include_reviewed = False
+    if get_active_role() == "admin":
+        include_reviewed = request.args.get("include_reviewed", "0") in ("1", "true", "yes", "on")
+
+    # Only consider recently relevant runs to keep the payload small.
+    # We intentionally avoid unbounded history polling.
+    days = 60
+    try:
+        days = int(request.args.get("days", "60"))
+    except Exception:
+        days = 60
+    if days < 1:
+        days = 1
+    if days > 180:
+        days = 180
+
+    now_utc = datetime.utcnow().replace(tzinfo=None)
+    window_start = now_utc - timedelta(days=days)
+
+    q = JobRun.query.filter(JobRun.autotask_ticket_id.isnot(None))
+    if not include_reviewed:
+        q = q.filter(JobRun.reviewed_at.is_(None))
+
+    # Only poll runs in our time window.
+    q = q.filter(func.coalesce(JobRun.run_at, JobRun.created_at) >= window_start)
+
+    runs = (
+        q.order_by(func.coalesce(JobRun.run_at, JobRun.created_at).desc(), JobRun.id.desc())
+        .limit(400)
+        .all()
+    )
+
+    ticket_ids = []
+    seen = set()
+    for r in runs:
+        tid = getattr(r, "autotask_ticket_id", None)
+        try:
+            tid_int = int(tid)
+        except Exception:
+            continue
+        if tid_int <= 0 or tid_int in seen:
+            continue
+        seen.add(tid_int)
+        ticket_ids.append(tid_int)
+
+    if not ticket_ids:
+        return jsonify({"status": "ok", "tickets": []})
+
+    # If integration is disabled, do not fail the page.
+    settings = _get_or_create_settings()
+    if not getattr(settings, "autotask_enabled", False):
+        return jsonify({"status": "ok", "tickets": [], "autotask_enabled": False})
+
+    try:
+        client = _build_autotask_client_from_settings()
+    except Exception as exc:
+        return jsonify({"status": "ok", "tickets": [], "autotask_enabled": True, "message": str(exc)})
+
+    corr_id = datetime.utcnow().strftime("rcpoll-%Y%m%d%H%M%S")
+
+    # Query tickets in Autotask (best-effort)
+    tickets = []
+    try:
+        tickets = client.query_tickets_by_ids(ticket_ids, corr_id=corr_id)
+    except Exception:
+        tickets = []
+
+    # Build a minimal payload for UI use.
+    out = []
+    for t in tickets or []:
+        if not isinstance(t, dict):
+            continue
+        tid = t.get("id")
+        try:
+            tid_int = int(tid)
+        except Exception:
+            continue
+
+        out.append(
+            {
+                "id": tid_int,
+                "ticketNumber": (t.get("ticketNumber") or t.get("TicketNumber") or "") or "",
+                "status": t.get("status"),
+                "statusName": (t.get("statusName") or t.get("StatusName") or "") or "",
+                "title": (t.get("title") or t.get("Title") or "") or "",
+                "lastActivityDate": (t.get("lastActivityDate") or t.get("LastActivityDate") or t.get("lastActivity") or "") or "",
+            }
+        )
+
+    return jsonify({"status": "ok", "tickets": out, "autotask_enabled": True})
 @main_bp.post("/api/run-checks/autotask-ticket")
 @login_required
 @roles_required("admin", "operator")
diff --git a/containers/backupchecks/src/templates/main/run_checks.html b/containers/backupchecks/src/templates/main/run_checks.html
index 7cfcd15..be31ea8 100644
--- a/containers/backupchecks/src/templates/main/run_checks.html
+++ b/containers/backupchecks/src/templates/main/run_checks.html
@@ -297,10 +297,48 @@
     var currentRunId = null;
     var currentPayload = null;
 
+    // Phase 2.1: Read-only Autotask ticket polling (Run Checks page only)
+    // Cache shape: { <ticketId>: {id, ticketNumber, status, statusName, title, lastActivityDate} }
+    var autotaskTicketPollCache = {};
+
+    function pollAutotaskTicketsOnPageOpen() {
+      // Only execute on Run Checks page load.
+      var url = '/api/run-checks/autotask-ticket-poll';
+      var qs = [];
+      // include_reviewed is only meaningful for admins
+      try {
+        var includeReviewed = {{ 'true' if include_reviewed else 'false' }};
+        if (includeReviewed) qs.push('include_reviewed=1');
+      } catch (e) {}
+      if (qs.length) url += '?' + qs.join('&');
+
+      fetch(url)
+        .then(function (r) { return r.json(); })
+        .then(function (j) {
+          if (!j || j.status !== 'ok') return;
+          autotaskTicketPollCache = {};
+          var list = (j.tickets || []);
+          for (var i = 0; i < list.length; i++) {
+            var t = list[i] || {};
+            var id = parseInt(t.id, 10);
+            if (!Number.isFinite(id) || id <= 0) continue;
+            autotaskTicketPollCache[id] = t;
+          }
+          window.__rcAutotaskTicketPollCache = autotaskTicketPollCache;
+        })
+        .catch(function () {
+          autotaskTicketPollCache = {};
+          window.__rcAutotaskTicketPollCache = autotaskTicketPollCache;
+        });
+    }
+
+
     var btnMarkAllReviewed = document.getElementById('rcm_mark_all_reviewed');
     var btnMarkSuccessOverride = document.getElementById('rcm_mark_success_override');
 
-    // Shift-click range selection for checkbox rows
+        pollAutotaskTicketsOnPageOpen();
+
+// Shift-click range selection for checkbox rows
     var lastCheckedCb = null;
 
     
@@ -864,14 +902,34 @@ table.addEventListener('change', function (e) {
       function renderAutotaskInfo(run) {
         if (!atInfo) return;
         var num = (run && run.autotask_ticket_number) ? String(run.autotask_ticket_number) : '';
+        var tid = (run && run.autotask_ticket_id) ? parseInt(run.autotask_ticket_id, 10) : null;
+        var polled = (tid && autotaskTicketPollCache && autotaskTicketPollCache[tid]) ? autotaskTicketPollCache[tid] : null;
+
+        var lines = [];
         if (num) {
-          atInfo.innerHTML = '<div><strong>Ticket:</strong> ' + escapeHtml(num) + '</div>';
-        } else if (run && run.autotask_ticket_id) {
-          atInfo.innerHTML = '<div><strong>Ticket:</strong> created</div>';
+          lines.push('<div><strong>Ticket:</strong> ' + escapeHtml(num) + '</div>');
+        } else if (tid) {
+          lines.push('<div><strong>Ticket:</strong> created</div>');
         } else {
-          atInfo.innerHTML = '<div class="text-muted">No Autotask ticket created for this run.</div>';
+          lines.push('<div class="text-muted">No Autotask ticket created for this run.</div>');
         }
-      }
+
+        // Phase 2.1 visibility only: show last polled status if available
+        if (tid) {
+          if (polled) {
+            var statusName = (polled.statusName || '').toString().trim();
+            var statusVal = (polled.status !== undefined && polled.status !== null) ? String(polled.status) : '';
+            var label = statusName ? statusName : (statusVal ? ('Status ' + statusVal) : '');
+            if (label) {
+              lines.push('<div class="text-muted">PSA status (polled): ' + escapeHtml(label) + '</div>');
+            }
+          } else {
+            lines.push('<div class="text-muted">PSA status (polled): not available</div>');
+          }
+        }
+
+        atInfo.innerHTML = lines.join('');
+}
       window.__rcmRenderAutotaskInfo = renderAutotaskInfo;
 
       if (btnAutotask) {
diff --git a/docs/backupchecks_autotask_integration_functional_design_living_document.md b/docs/backupchecks_autotask_integration_functional_design_living_document.md
new file mode 100644
index 0000000..d544481
--- /dev/null
+++ b/docs/backupchecks_autotask_integration_functional_design_living_document.md
@@ -0,0 +1,412 @@
+# Backupchecks – Autotask Integration
+
+## Functional Design
+
+*Last updated: 2026-01-16*
+
+---
+
+## 1. Scope & Goals
+
+This document describes the **functional design and agreed decisions** for the first phase of the Autotask integration in Backupchecks.
+
+Goals for phase 1:
+
+- Allow operators to **manually create Autotask tickets** from Backupchecks.
+- Ensure **full operator control** over when a ticket is created.
+- Prevent ticket spam and duplicate tickets.
+- Maintain clear ownership between Backupchecks and Autotask.
+- Provide a safe and auditable way to resolve tickets from Backupchecks.
+
+Out of scope for phase 1:
+
+- Automatic ticket creation
+- Automatic ticket closing on success
+- Issue correlation across multiple runs
+- Time entry creation or modification
+
+---
+
+## 2. Core Principles (Leading)
+
+These principles apply to all design and implementation choices:
+
+- Autotask is an **external authoritative system** (PSA).
+- Backupchecks is a **consumer**, not an owner, of PSA data.
+- **IDs are leading**, names are display-only.
+- All PSA mappings are **explicit**, never implicit or automatic.
+- Operators always retain **manual control**.
+- Renaming in Autotask must **never break mappings**.
+
+---
+
+## 3. Customer ↔ Autotask Company Mapping
+
+### 3.1 Mapping model
+
+- Mapping is configured in the **Customers** screen.
+- Mapping is a **1-to-1 explicit relationship**.
+- Stored values per customer:
+  - PSA type: autotask
+  - Autotask Company ID (leading)
+  - Autotask Company Name (cached for display)
+  - Last sync timestamp
+  - Mapping status: ok | renamed | missing | invalid
+
+The Autotask Company ID is the source of truth. The name exists only for UI clarity.
+
+### 3.2 Name synchronisation
+
+- If the company name is changed in Autotask:
+  - Backupchecks updates the cached name automatically.
+  - The mapping remains intact.
+- Backupchecks customer names are independent and never overwritten.
+
+### 3.3 Failure scenarios
+
+- Autotask company deleted or inaccessible:
+  - Mapping status becomes invalid.
+  - Ticket creation is blocked.
+  - UI clearly indicates broken mapping.
+
+---
+
+## 4. Ticket Creation Model
+
+### 4.1 Operator-driven creation
+
+- Tickets are created only via an explicit operator action.
+- Location: Run Checks page.
+- Manual ticket number input is removed.
+- A new action replaces it: Create Autotask ticket.
+
+### 4.2 One ticket per run
+
+- Exactly one ticket per run.
+- A run can never create multiple tickets.
+- If a ticket exists:
+  - Creation action is replaced by Open ticket.
+
+### 4.3 Ticket contents (baseline)
+
+Minimum ticket fields:
+
+- Subject: [Backupchecks]  -  -&#x20;
+- Description:
+  - Run date/time
+  - Backup type and job
+  - Affected objects
+  - Error or warning messages
+  - Reference to Backupchecks
+
+---
+
+## 5. Ticket State Tracking in Backupchecks
+
+Per run, Backupchecks stores:
+
+- Autotask Ticket ID
+- Autotask Ticket Number
+- Ticket URL
+- Created by
+- Created at timestamp
+- Last known ticket status (snapshot)
+
+---
+
+## 6. Ticket Resolution from Backupchecks
+
+Backupchecks may resolve a ticket only if:
+
+- The ticket exists
+- The ticket is not already closed
+- No time entries are present
+
+If time entries exist, the ticket is not closed and an internal system note is added.
+
+---
+
+## 7. Backupchecks Settings
+
+Settings → Extensions & Integrations → Autotask
+
+Includes:
+
+- Enable integration (on/off)
+- Environment
+- API credentials
+- Tracking Identifier
+- Default queue and status
+- Priority mapping
+
+### 7.1 Enable / disable behaviour (mandatory)
+
+Backupchecks must support switching the Autotask integration **on and off at any time**.
+
+When Autotask integration is **enabled**:
+- Autotask actions are available (create ticket, resolve ticket, link existing ticket).
+- Ticket polling/synchronisation (Phase 2) is active.
+
+When Autotask integration is **disabled**:
+- Backupchecks falls back to the manual workflow:
+  - Operators can manually enter ticket numbers.
+  - No Autotask API calls are executed.
+  - No polling is performed.
+  - No resolve action is available (as it would require Autotask calls).
+- Existing stored Autotask references remain visible for audit/history.
+
+The enable/disable switch must be reversible and must not require data deletion or migration.
+
+---
+
+## 8. Roles & Permissions
+
+- Admin / Operator: create and resolve tickets
+- Reporter: view-only access
+
+---
+
+## 9. Explicit Non-Goals (Phase 1)
+
+- Automatic ticket creation
+- Automatic ticket closing
+- Time entry handling
+- Multiple tickets per run
+- PSA-side logic
+
+---
+
+## 10. Phase 1 Summary
+
+Phase 1 delivers controlled, operator-driven PSA integration with a strong focus on auditability and predictability.
+
+---
+
+## 11. Phase 2 – Ticket State Synchronisation (PSA-driven)
+
+This phase introduces **PSA-driven state awareness** for already linked tickets. The goal is to keep Backupchecks aligned with Autotask **without introducing active control or automation**.
+
+### 11.1 Polling strategy (Run Checks entry point)
+
+- Polling is executed **only when Autotask integration is enabled**.
+- When the **Run Checks** page is opened, Backupchecks performs a **targeted poll** to Autotask.
+
+- When the **Run Checks** page is opened, Backupchecks performs a **targeted poll** to Autotask.
+- Only tickets that are:
+  - Linked to runs shown on the page, and
+  - Not in a terminal state inside Backupchecks
+  are included.
+- Tickets already marked as resolved or broken are excluded.
+
+This prevents unnecessary API calls and limits polling to operator-relevant context.
+
+### 11.2 Active-ticket-only retrieval
+
+- Backupchecks only queries tickets that are considered **active** in Autotask.
+- Completed or closed tickets are not included in the active-ticket query.
+- This ensures minimal load and avoids repeated retrieval of historical data.
+
+### 11.3 PSA-driven completion handling
+
+If Autotask reports a ticket with status **Completed**:
+
+- The linked run in Backupchecks is automatically marked as **Resolved**.
+- The resolution is explicitly flagged as:
+  - **Resolved by PSA**
+- Backupchecks does not add notes or modify the ticket in Autotask.
+
+UI behaviour:
+- Operators can clearly see that the resolution originated from the PSA.
+- A visual indicator highlights that the underlying backup issue may still require verification.
+
+### 11.4 Operator awareness and follow-up
+
+When a ticket is resolved by PSA:
+
+- Backupchecks does not assume the technical issue is resolved.
+- Operators are expected to:
+  - Review the related run
+  - Decide whether further action is required inside Backupchecks
+
+No automatic reopening or ticket creation is performed.
+
+### 11.5 Deleted ticket detection
+
+If a linked ticket is **deleted in Autotask**:
+
+- Backupchecks detects this during polling.
+- The ticket linkage is marked as:
+  - **Deleted in PSA**
+
+UI behaviour:
+- A clear warning is shown to the operator.
+- The historical ticket reference remains visible for audit purposes.
+- Ticket-related actions are blocked until the operator:
+  - Links a replacement ticket, or
+  - Creates a new Autotask ticket
+
+### 11.6 Ticket resolution from Backupchecks (operator-driven)
+
+Phase 2 includes implementation of **manual ticket resolution** from Backupchecks under the already defined Phase 1 rules.
+
+- Resolution is always an explicit operator action (no automation).
+- Resolution rules remain leading (see Chapter 6):
+  - Ticket must exist
+  - Ticket must not already be closed
+  - Ticket may only be closed by Backupchecks if **no time entries** exist
+  - If time entries exist, Backupchecks adds an internal system note and leaves the ticket open
+
+UI behaviour (Run Checks and Job Details):
+- Show a Resolve ticket action only when a validated Autotask Ticket ID exists.
+- When resolution succeeds, update the run to Resolved and store:
+  - Resolved timestamp
+  - Resolved by (operator)
+  - Resolution origin: Resolved by Backupchecks
+
+Important alignment with PSA-driven sync:
+- If Autotask later reports the ticket as Completed, Backupchecks keeps the run resolved, but the origin remains:
+  - Resolved by Backupchecks
+- If Autotask reports completion before the operator resolves it, Backupchecks sets:
+  - Resolved by PSA
+
+### 11.7 Explicit non-goals (Phase 2)
+
+The following remain explicitly out of scope:
+
+- Automatic ticket creation
+- Automatic ticket reopening
+- Automatic resolution without operator intent
+- Status pushing from Backupchecks to Autotask (except the explicit Resolve action described above)
+- Any modification of existing Autotask ticket content (except fixed-format internal system notes used during resolution rules)
+
+---
+
+## 12. Future Design Considerations (Post-Phase 2)
+
+The following sections describe **future design intent only**. They are explicitly **out of scope for Phase 2** and introduce no implementation commitments.
+
+### 12.1 Ticket lifecycle awareness (read-only intelligence)
+
+Objective:
+Provide better insight into the state of linked tickets without adding actions.
+
+Scope:
+- Periodic read-only retrieval of ticket status
+- Display of:
+  - Current status
+  - Queue
+  - Assigned resource (owner)
+
+Shown in:
+- Run Checks
+- Job Details
+- Tickets / Remarks overview
+
+Explicitly excluded:
+- No automatic actions
+- No status synchronisation back to Autotask
+
+Value:
+- Operators need to open Autotask less frequently
+- Faster visibility into whether a ticket has been picked up
+
+### 12.2 Operator notes & context enrichment
+
+Objective:
+Add contextual information to existing tickets without taking ownership away from the PSA.
+
+Scope:
+- Add internal/system notes from Backupchecks
+- Notes are always written in a fixed format
+- Notes are added only by explicit operator action
+
+Rules:
+- Never overwrite existing ticket content
+- Never create customer-facing notes
+- Never generate notes automatically
+
+Value:
+- Tickets remain up to date without duplication
+- Autotask remains the authoritative system
+
+### 12.3 Controlled assistance (semi-automatic support)
+
+Objective:
+Support operator decision-making without introducing automation.
+
+Examples:
+- Suggestion: a similar error already has an open ticket
+- Suggestion: previous run was successful, consider resolving the ticket
+- Highlight repeated failures without any linked ticket
+
+Important constraints:
+- Suggestions only
+- No automatic ticket creation
+- No automatic ticket closure
+
+Value:
+- Reduced human error
+- No loss of operator control
+
+### 12.4 Cross-run correlation (analytical)
+
+Objective:
+Provide insight into structural or recurring problems before tickets are created.
+
+Scope:
+- Detection of repeated failures across multiple runs
+- Detection of the same object with the same error over time
+- Visualisation inside Backupchecks only
+
+Explicitly excluded:
+- Ticket bundling
+- Ticket merging
+- Any Autotask-side modifications
+
+Value:
+- Better decisions prior to ticket creation
+- Reduced noise in the PSA
+
+### 12.5 Multi-PSA abstraction (design preparation)
+
+Objective:
+Prepare the internal design for future PSA support without implementing it.
+
+Scope:
+- PSA-agnostic internal models:
+  - Ticket
+  - Company mapping
+  - Resolution rules
+- Autotask remains the only concrete implementation
+
+Why this is documented now:
+- Prevents Autotask-specific technical debt
+- Keeps the architecture open for other PSA platforms
+
+### 12.6 Governance & audit depth
+
+Objective:
+Ensure full traceability for MSP and enterprise environments.
+
+Scope:
+- Extended audit logging:
+  - Who created, linked or resolved a ticket
+  - When the action occurred
+  - From which run the action originated
+- Read-only export capabilities
+- Optional compliance-oriented views
+
+Value:
+- MSP and enterprise readiness
+- Supports internal and external audits
+
+### 12.7 Explicit non-directions
+
+The following are intentionally excluded unless a strategic decision is made later:
+
+- Automatic ticket creation
+- Automatic ticket handling
+- Time registration
+- Mutation of existing ticket content
+- PSA business logic inside Backupchecks
+
diff --git a/docs/backupchecks_autotask_integration_functional_design_phase_1.md b/docs/backupchecks_autotask_integration_functional_design_phase_1.md
deleted file mode 100644
index 0575753..0000000
--- a/docs/backupchecks_autotask_integration_functional_design_phase_1.md
+++ /dev/null
@@ -1,464 +0,0 @@
-# Backupchecks – Autotask Integration
-
-## Functional Design – Phase 1
-
-_Last updated: 2026-01-13_
-
----
-
-## 1. Scope & Goals
-
-This document describes the **functional design and agreed decisions** for the first phase of the Autotask integration in Backupchecks.
-
-Goals for phase 1:
-- Allow operators to **manually create Autotask tickets** from Backupchecks.
-- Ensure **full operator control** over when a ticket is created.
-- Prevent ticket spam and duplicate tickets.
-- Maintain clear ownership between Backupchecks and Autotask.
-- Provide a safe and auditable way to resolve tickets from Backupchecks.
-
-Out of scope for phase 1:
-- Automatic ticket creation
-- Automatic ticket closing on success
-- Issue correlation across multiple runs
-- Time entry creation or modification
-
----
-
-## 2. Core Principles (Leading)
-
-These principles apply to all design and implementation choices:
-
-- Autotask is an **external authoritative system** (PSA).
-- Backupchecks is a **consumer**, not an owner, of PSA data.
-- **IDs are leading**, names are display-only.
-- All PSA mappings are **explicit**, never implicit or automatic.
-- Operators always retain **manual control**.
-- Renaming in Autotask must **never break mappings**.
-
----
-
-## 3. Customer ↔ Autotask Company Mapping
-
-### 3.1 Mapping model
-
-- Mapping is configured in the **Customers** screen.
-- Mapping is a **1-to-1 explicit relationship**.
-- Stored values per customer:
-  - PSA type: `autotask`
-  - Autotask Company ID (leading)
-  - Autotask Company Name (cached for display)
-  - Last sync timestamp
-  - Mapping status: `ok | renamed | missing | invalid`
-
-> **Note:** The Autotask Company ID is the source of truth. The name exists only for UI clarity.
-
-### 3.2 Name synchronisation
-
-- If the company name is changed in Autotask:
-  - Backupchecks updates the cached name automatically.
-  - The mapping remains intact.
-- Backupchecks customer names are **independent** and never overwritten.
-
-### 3.3 Failure scenarios
-
-- Autotask company deleted or inaccessible:
-  - Mapping status becomes `invalid`.
-  - Ticket creation is blocked.
-  - UI clearly indicates broken mapping.
-
----
-
-## 4. Ticket Creation Model
-
-### 4.1 Operator-driven creation
-
-- Tickets are created **only** via an explicit operator action.
-- Location: **Run Checks** page.
-- Manual ticket number input is removed.
-- A new action replaces it:
-  - **“Create Autotask ticket”**
-
-> **Rationale:** There are too many backup alerts that do not require a ticket. Human judgement remains essential.
-
-### 4.2 One ticket per run (Key decision)
-
-- **Exactly one ticket per Run**.
-- A run can never create multiple tickets.
-- If a ticket exists:
-  - Creation action is replaced by:
-    - “Open ticket”
-    - (Later) “Add note”
-
-> **Rationale:** Multiple errors within a run often share the same root cause. This prevents ticket flooding.
-
-### 4.3 Ticket contents (baseline)
-
-Minimum ticket fields:
-- Subject:
-  - `[Backupchecks] <Customer> - <Job> - <Status>`
-- Description:
-  - Run date/time
-  - Backup type and job
-  - Affected objects (e.g. HV01, USB Disk)
-  - Error / warning messages
-  - Reference to Backupchecks (URL or identifier)
-
-Optional (configurable later):
-- Queue
-- Issue type / category
-- Priority mapping
-
----
-
-## 5. Ticket State Tracking in Backupchecks
-
-Per Run, Backupchecks stores:
-- Autotask Ticket ID
-- Autotask Ticket Number
-- Ticket URL (optional)
-- Created by (operator)
-- Created at timestamp
-- Last known ticket status (snapshot)
-
-This ensures:
-- No duplicate tickets
-- Full audit trail
-n- Clear operator feedback
-
----
-
-## 5A. Ticket Content Composition Rules
-
-This chapter defines how Backupchecks determines **what content is placed in an Autotask ticket**, with the explicit goal of keeping tickets readable and actionable.
-
-### 5A.1 Guiding principle
-
-- A ticket is a **signal**, not a log file.
-- The ticket must remain readable for the ticket owner.
-- Full technical details always remain available in Backupchecks.
-
-### 5A.2 Content hierarchy (deterministic)
-
-Backupchecks applies the following strict hierarchy when composing ticket content:
-
-1. **Overall remark** (run-level summary) – if present, this is leading.
-2. **Object-level messages** – used only when no overall remark exists.
-
-This hierarchy is fixed and non-configurable in phase 1.
-
-### 5A.3 Scenario A – Overall remark present
-
-If an overall remark exists for the run:
-- The ticket description contains:
-  - The overall remark
-  - Job name, run date/time, and status
-- Object-level errors are **not listed in full**.
-- A short informational line is added:
-  - “Multiple objects reported errors. See Backupchecks for full details.”
-
-> **Rationale:** The overall remark already represents a consolidated summary. Listing many objects would reduce ticket clarity.
-
-### 5A.4 Scenario B – No overall remark
-
-If no overall remark exists:
-- The ticket description includes object-level errors.
-- Object listings are **explicitly limited**:
-  - A maximum of *N* objects (exact value defined during implementation)
-- If more objects are present:
-  - “And X additional objects reported similar errors.”
-
-> **Rationale:** Prevents large, unreadable tickets while still providing concrete examples.
-
-### 5A.5 Mandatory reference to Backupchecks
-
-Every ticket created by Backupchecks must include a **direct link to the Job Details page of the originating run**.
-
-This link is intended as the primary navigation entry point for the ticket owner.
-
-The ticket description must include:
-- Job name
-- Run date/time
-- A clickable URL pointing to the Job Details page of that run in Backupchecks
-
-> **Rationale:** The Job Details page provides the most complete and structured context for investigation.
-
-This ensures:
-- Full traceability
-- Fast access to complete technical details
-
----
-
-### 5A.6 Explicit exclusions
-
-The following content is deliberately excluded from ticket descriptions:
-- Complete object lists when large
-- Repeated identical error messages
-- Raw technical dumps or stack traces
-
----
-
-## 6. Ticket Resolution from Backupchecks
-
-### 6.1 Resolution policy
-
-Backupchecks **may resolve** an Autotask ticket **only if**:
-- The ticket exists
-- The ticket is not already closed
-- **No time entries are present on the ticket**
-
-This rule is **mandatory and non-configurable**.
-
-> **Rationale:** Prevents financial and operational conflicts inside Autotask.
-
-### 6.2 Behaviour when time entries exist
-
-If an operator clicks **Resolve ticket** but the ticket **contains time entries**:
-- The ticket **must not be closed** by Backupchecks.
-- Backupchecks **adds an internal system note** to the ticket stating that it was marked as resolved from Backupchecks.
-- The ticket remains open for the ticket owner to review and close manually.
-
-Proposed internal system note text:
-
-> `Ticket marked as resolved in Backupchecks, but not closed automatically because time entries are present.`
-
-> **Rationale:** Ensures the ticket owner is explicitly informed without violating Autotask process or financial controls.
-
-### 6.3 Closing note (fixed text)
-
-When resolving a ticket **and no time entries are present**, Backupchecks always adds the following **internal system note** **before closing**:
-
-> `Ticket resolved via Backupchecks after verification that the backup issue is no longer present.`
-
-Characteristics:
-- Fixed text (no operator editing in phase 1)
-- **System / internal note** (never customer-facing)
-- Ensures auditability and traceability
-
----
-
----
-
-## 6A. Handling Existing Tickets & Compatibility Mode
-
-### 6A.1 Existing manual ticket numbers
-
-In the pre-integration workflow, a run may already contain a manually entered ticket number.
-
-When Autotask integration is **enabled**:
-- Existing ticket numbers remain visible.
-- Backupchecks may offer a one-time action:
-  - **“Link existing Autotask ticket”**
-  - This validates the ticket in Autotask and stores the **Autotask Ticket ID**.
-
-> **Note:** Without an Autotask Ticket ID, Backupchecks must not attempt to resolve a ticket.
-
-When Autotask integration is **disabled**:
-- The current/manual workflow applies (manual ticket number entry).
-
-### 6A.2 Linking existing Autotask tickets
-
-When integration is enabled, operators can link an existing Autotask ticket to a run:
-- Search/select a ticket (preferably by ticket number)
-- Store:
-  - Autotask Ticket ID
-  - Autotask Ticket Number
-  - Ticket URL (optional)
-
-After linking:
-- The run behaves like an integration-created ticket for viewing and resolution rules.
-
-### 6A.3 Compatibility mode (optional setting)
-
-Optional setting (recommended for transition periods):
-- **“Allow manual ticket number entry when Autotask is enabled”** (default: OFF)
-
-Behaviour:
-- When ON, operators can still manually enter a ticket number even if integration is enabled.
-- Resolve from Backupchecks is still only possible for tickets that have a validated Autotask Ticket ID.
-
-> **Rationale:** Provides a safe escape hatch during rollout and migration.
-
----
-
-## 6B. Deleted Tickets in Autotask
-
-Tickets may be deleted in Autotask. When a ticket referenced by Backupchecks is deleted, the linkage becomes invalid.
-
-### 6B.1 Detection
-
-When Backupchecks attempts to fetch the ticket by Autotask Ticket ID:
-- If Autotask returns “not found” (deleted/missing), Backupchecks marks the linkage as **broken**.
-
-### 6B.2 Behaviour when a ticket is deleted
-
-- The run keeps the historical reference (ticket number/ID) for audit purposes.
-- The ticket state is shown as:
-  - **“Missing in Autotask (deleted)”**
-- Actions are blocked:
-  - No “Open ticket” (if no valid URL)
-  - No “Resolve ticket”
-- Operators can choose:
-  - **Re-link to another ticket** (if the ticket was recreated or replaced)
-  - **Create a new Autotask ticket** (creates a new link for that run)
-
-> **Note:** Backupchecks should never silently remove the stored linkage, to preserve auditability.
-
-### 6B.3 Optional: periodic validation
-
-Optionally (later), Backupchecks may periodically validate linked ticket IDs and flag missing tickets.
-
----
-
-## 7. Backupchecks Settings
-
-### 7.1 New settings section
-
-**Settings → Extensions & Integrations → Autotask**
-
-### 7.2 Required settings
-
-- Enable Autotask integration (on/off)
-- Environment: Sandbox / Production
-- API Username
-- API Password
-- Tracking Identifier
-
-### 7.3 Ticket creation defaults (configurable)
-
-These defaults are applied when Backupchecks creates a new Autotask ticket.
-
-- Ticket Source (default): **Monitoring Alert**
-- Default Queue (default): **Helpdesk**
-- Default Status (default): **New**
-- Priority mapping:
-  - Warning → **Medium**
-  - Error → **High**
-
-> **Note:** Issue Type / Category is intentionally **not set** by Backupchecks and will be assigned by the ticket owner or traffic manager.
-
----
-
-### 7.3A Backupchecks Base URL
-
-- Base URL of the Backupchecks instance (e.g. `https://backupchecks.example.com`)
-
-This value is required to construct:
-- Direct links to Job Details pages
-- Stable references inside Autotask tickets
-
-> **Note:** This setting is mandatory for ticket creation and must be validated.
-
----
-
-### 7.4 Dynamic reference data
-
-Backupchecks must retrieve the following reference data from Autotask and present it in Settings:
-- Available Queues
-- Available Ticket Sources
-
-These lists are:
-- Loaded on demand (or via refresh action)
-- Stored for selection in Settings
-
-> **Rationale:** Prevents hard-coded values and keeps Backupchecks aligned with Autotask configuration changes.
-
-### 7.5 Resolve configuration
-
-- Allow resolving tickets from Backupchecks (on/off)
-- Closing note texts (read-only, fixed):
-  - Standard resolve note
-  - Time-entry-blocked resolve note
-
-### 7.6 Validation & diagnostics
-
-- Test connection
-- Validate configuration (credentials, reference data access)
-- Optional API logging level
-
----
-
-## 8. Roles & Permissions
-
-- Admin / Operator:
-  - Create tickets
-  - Resolve tickets (if allowed)
-- Reporter:
-  - View ticket number and link
-  - No create or resolve actions
-
----
-
-## 9. Handling Existing, Linked and Deleted Tickets
-
-### 9.1 Existing tickets (pre-integration)
-
-- Runs that already contain a manually entered ticket number remain valid.
-- When Autotask integration is enabled, operators may optionally:
-  - Link the run to an existing Autotask ticket (validated against Autotask).
-  - After linking, the run follows the same rules as integration-created tickets.
-
-> **Note:** This optional compatibility flow exists to support a gradual transition and avoids forced migration.
-
-### 9.2 Optional compatibility mode
-
-- Optional setting: **Allow manual ticket number entry when Autotask is enabled**
-- Default: OFF
-- Intended as a temporary transition mechanism.
-
-### 9.3 Deleted tickets in Autotask (important case)
-
-Tickets may be deleted directly in Autotask. Backupchecks must handle this safely and explicitly.
-
-Behaviour:
-- Backupchecks never assumes tickets exist based on stored data alone.
-- On any ticket-related action (view, resolve, open):
-  - Backupchecks validates the ticket ID against Autotask.
-
-If Autotask returns *not found*:
-- The ticket is marked as **Deleted (external)**.
-- The existing link is preserved as historical data but marked inactive.
-- No further actions (resolve, update) are allowed on that ticket.
-
-UI behaviour:
-- Ticket number remains visible with a clear indicator:
-  - “Ticket deleted in Autotask”
-- Operator is offered one explicit action:
-  - “Create new Autotask ticket” (results in a new ticket linked to the same run)
-
-> **Rationale:** Ticket deletion is an external administrative decision. Backupchecks records the fact but does not attempt to repair or hide it.
-
-### 9.4 Why links are not silently removed
-
-- Silent removal would break audit trails.
-- Historical runs must retain context, even if external objects no longer exist.
-- Operators must explicitly decide how to proceed.
-
----
-
-## 10. Explicit Non-Goals (Phase 1)
-
-The following are explicitly excluded:
-- Automatic ticket creation
-- Automatic ticket closing
-- Automatic re-creation of deleted tickets
-- Updating ticket content after creation
-- Multiple tickets per run
-- Time entry handling
-- Multi-PSA support
-
----
-
-## 11. Phase 1 Summary
-
-Phase 1 delivers:
-- Safe, controlled PSA integration
-- Operator-driven ticket lifecycle
-- Explicit handling of legacy, linked and deleted tickets
-- Clear audit trail
-- Minimal risk to Autotask data integrity
-
-This design intentionally prioritises **predictability and control** over automation.
-
-Future phases may build on this foundation.
-
diff --git a/docs/backupchecks_autotask_integration_phase_2_implementation.md b/docs/backupchecks_autotask_integration_phase_2_implementation.md
new file mode 100644
index 0000000..10e4b75
--- /dev/null
+++ b/docs/backupchecks_autotask_integration_phase_2_implementation.md
@@ -0,0 +1,432 @@
+# Backupchecks – Autotask Integration
+
+## Phase 2 – Implementation Design
+
+*Document type: Implementation design*
+*Scope: Phase 2 only*
+
+---
+
+## 1. Purpose
+
+This document describes the **technical implementation approach** for Phase 2 of the Autotask integration. Phase 2 focuses on **ticket state synchronisation and operator-driven resolution**, based on the approved functional design.
+
+No future concepts or post–Phase 2 ideas are included in this document.
+
+---
+
+## 2. Preconditions
+
+Phase 2 assumes:
+
+- Phase 1 is fully implemented and deployed
+- Autotask integration can be enabled and disabled at runtime
+- Tickets are already linked to runs via Autotask Ticket ID
+- Backupchecks is not the authoritative system for ticket state
+
+---
+
+## 3. High-level Behaviour Overview
+
+Phase 2 is implemented in **controlled sub-phases**. Each phase introduces a limited set of actions and ends with an explicit **functional validation moment** before continuing.
+
+The sub-phases are:
+
+- Phase 2.1 – Read-only ticket polling
+- Phase 2.2 – PSA-driven resolution handling
+- Phase 2.3 – Deleted ticket detection
+- Phase 2.4 – Manual ticket resolution from Backupchecks
+
+---
+
+## 4. Phase 2.1 – Read-only Ticket Polling
+
+### 4.1 Scope
+
+This phase introduces **read-only polling** of Autotask ticket state. No mutations or resolution logic is applied.
+
+### 4.2 Trigger point
+
+Polling is triggered when:
+
+- Autotask integration is enabled
+- The **Run Checks** page is opened
+
+There is no background scheduler or periodic task.
+
+### 4.3 Polling scope
+
+Only tickets that meet **all** of the following criteria are included:
+
+- Ticket is linked to a run visible on the Run Checks page
+- Run is not already resolved in Backupchecks
+- Ticket is not marked as deleted or invalid
+
+### 4.4 Autotask query strategy
+
+- Query only **active tickets** in Autotask
+- Ticket ID is always used as the lookup key
+
+### 4.5 Control moment – Phase 2.1
+
+Functional validation:
+
+- Run Checks page loads without delay
+- Correct tickets are polled
+- No state changes occur in Backupchecks
+- No Autotask data is modified
+
+---
+
+### 4.2 Polling scope
+
+Only tickets that meet **all** of the following criteria are included:
+
+- Ticket is linked to a run visible on the Run Checks page
+- Run is not already resolved in Backupchecks
+- Ticket is not marked as deleted or invalid
+
+This guarantees:
+
+- Minimal API usage
+- Operator-context-only data retrieval
+
+---
+
+### 4.3 Autotask query strategy
+
+- Query only **active tickets** in Autotask
+- Completed / closed tickets are excluded from the active query
+- Ticket ID is always used as the lookup key
+
+If an expected ticket is not returned:
+
+- A follow-up single-ticket lookup is executed
+- If still not found, the ticket is treated as **deleted in PSA**
+
+---
+
+## 5. Phase 2.2 – PSA-driven Resolution Handling
+
+### 5.1 Scope
+
+This phase adds **state interpretation** on top of read-only polling.
+
+### 5.2 Completed ticket handling
+
+If Autotask reports the ticket status as **Completed**:
+
+- Mark the linked run as **Resolved**
+- Set resolution origin to:
+  - `Resolved by PSA`
+- Store resolution timestamp
+
+No write-back to Autotask is performed.
+
+### 5.3 Active ticket handling
+
+If the ticket exists and is active:
+
+- Update cached ticket status snapshot only
+- No state change in Backupchecks
+
+### 5.4 Control moment – Phase 2.2
+
+Functional validation:
+
+- PSA-completed tickets resolve runs correctly
+- Resolution origin is shown correctly
+- Active tickets do not alter run state
+
+---
+
+### 5.2 Completed ticket
+
+If Autotask reports the ticket status as **Completed**:
+
+- Mark the linked run as **Resolved**
+- Set resolution origin to:
+  - `Resolved by PSA`
+- Store resolution timestamp
+
+No write-back to Autotask is performed.
+
+---
+
+### 5.3 Deleted or missing ticket
+
+If the ticket cannot be found in Autotask:
+
+- Mark ticket linkage as:
+  - `Deleted in PSA`
+- Block ticket-related actions
+- Preserve historical references (ID, number, URL)
+
+Operator must explicitly link or create a replacement ticket.
+
+---
+
+## 6. Phase 2.3 – Deleted Ticket Detection
+
+### 6.1 Scope
+
+This phase introduces detection of tickets that are removed from Autotask.
+
+### 6.2 Detection logic
+
+If a linked ticket is not returned by the active-ticket query:
+
+- Execute a single-ticket lookup
+- If still not found:
+  - Mark ticket linkage as `Deleted in PSA`
+
+### 6.3 Behaviour
+
+- Ticket actions are blocked
+- Historical references remain visible
+- Operator must explicitly relink or recreate a ticket
+
+### 6.4 Control moment – Phase 2.3
+
+Functional validation:
+
+- Deleted tickets are detected reliably
+- Warning is visible in UI
+- No silent unlinking occurs
+
+---
+
+## 7. Phase 2.4 – Manual Ticket Resolution (Backupchecks → Autotask)
+
+### 7.1 Preconditions
+
+The Resolve action is available only if:
+
+- Autotask integration is enabled
+- A valid Autotask Ticket ID exists
+- Ticket is not already closed in PSA
+
+### 7.2 Resolution flow
+
+1. Operator triggers **Resolve ticket**
+2. Backupchecks retrieves ticket details from Autotask
+3. Time entry check is executed
+
+#### Case A – No time entries
+
+- Ticket is set to completed in Autotask
+- Run is marked as **Resolved**
+- Resolution origin:
+  - `Resolved by Backupchecks`
+
+#### Case B – Time entries exist
+
+- Ticket is not closed
+- Fixed-format internal system note is added
+- Run remains unresolved
+
+### 7.3 Control moment – Phase 2.4
+
+Functional validation:
+
+- Resolution works only under defined rules
+- Time entry logic is respected
+- Resolution origin is persisted correctly
+
+---
+
+### 6.2 Resolution flow
+
+1. Operator triggers **Resolve ticket**
+2. Backupchecks retrieves ticket details from Autotask
+3. Time entry check is executed
+
+#### Case A – No time entries
+
+- Ticket is set to the configured completed status in Autotask
+- Run is marked as **Resolved**
+- Resolution origin:
+  - `Resolved by Backupchecks`
+
+#### Case B – Time entries exist
+
+- Ticket is not closed
+- A fixed-format internal system note is added
+- Run remains unresolved
+
+---
+
+### 6.3 Post-resolution sync alignment
+
+If a ticket resolved by Backupchecks is later polled as Completed:
+
+- Backupchecks keeps the existing resolved state
+- Resolution origin remains:
+  - `Resolved by Backupchecks`
+
+If Autotask resolves the ticket first:
+
+- Backupchecks sets:
+  - `Resolved by PSA`
+
+---
+
+## 7. Data Model Adjustments
+
+Phase 2 requires the following additional fields per run:
+
+- `ticket_last_polled_at`
+- `ticket_resolution_origin`:
+  - `psa`
+  - `backupchecks`
+- `ticket_deleted_in_psa` (boolean)
+
+Existing Phase 1 fields remain unchanged.
+
+---
+
+## 8. UI Behaviour
+
+### 8.1 Run Checks
+
+- Visual indicator for linked tickets
+- Resolution origin badge:
+  - Resolved by PSA
+  - Resolved by Backupchecks
+- Warning banner for deleted tickets
+
+---
+
+### 8.2 Job Details
+
+- Same indicators as Run Checks
+- Resolve action visibility follows resolution rules
+
+---
+
+## 9. Error Handling & Logging
+
+- All Autotask API calls are logged with:
+  - Correlation ID
+  - Ticket ID
+  - Run ID
+
+- Polling failures do not block page rendering
+- Partial polling failures are tolerated per ticket
+
+---
+
+## 10. Explicit Non-Implementation (Phase 2)
+
+The following are **not implemented**:
+
+- Background schedulers
+- Automatic ticket creation
+- Automatic ticket reopening
+- Status pushing without operator action
+- Ticket content mutation beyond fixed system notes
+
+---
+
+## 11. Phase-based Implementation Workflow
+
+For each Phase 2 sub-phase, a **dedicated chat** must be used. This ensures focus, traceability, and controlled implementation.
+
+The instructions below must be copied **verbatim** when starting a new chat for the corresponding phase.
+
+---
+
+## Phase 2.1 – Chat Instructions
+
+Purpose:
+Implement **read-only ticket polling** when the Run Checks page is opened.
+
+Chat instructions:
+
+- Scope is limited to Phase 2.1 only
+- No ticket state changes are allowed
+- No resolve, close, or mutation logic may be added
+- Only backend polling and UI visibility updates are permitted
+- All changes must be functionally testable on Run Checks
+
+Exit criteria:
+
+- Polling executes only when Run Checks is opened
+- Only relevant active tickets are queried
+- No Backupchecks run state is modified
+
+---
+
+## Phase 2.2 – Chat Instructions
+
+Purpose:
+Implement **PSA-driven resolution handling** based on polling results.
+
+Chat instructions:
+
+- Phase 2.1 must already be completed and validated
+- Only Completed ticket handling may be added
+- Resolution origin must be stored and displayed
+- No Backupchecks-initiated ticket changes are allowed
+
+Exit criteria:
+
+- Completed tickets resolve runs correctly
+- Resolution origin is accurate and persistent
+- Active tickets remain unchanged
+
+---
+
+## Phase 2.3 – Chat Instructions
+
+Purpose:
+Implement **deleted ticket detection and operator visibility**.
+
+Chat instructions:
+
+- Phase 2.1 and 2.2 must already be completed
+- Detection must be explicit and non-destructive
+- Historical ticket references must remain intact
+- UI must clearly indicate deleted state
+
+Exit criteria:
+
+- Deleted tickets are reliably detected
+- Operators are clearly informed
+- Ticket actions are blocked correctly
+
+---
+
+## Phase 2.4 – Chat Instructions
+
+Purpose:
+Implement **manual ticket resolution from Backupchecks to Autotask**.
+
+Chat instructions:
+
+- All previous Phase 2 sub-phases must be completed
+- Resolution must be strictly operator-driven
+- Time entry rules must be enforced exactly
+- Resolution origin must be stored correctly
+
+Exit criteria:
+
+- Tickets are resolved only when allowed
+- Time entry edge cases behave correctly
+- State remains consistent with PSA polling
+
+---
+
+## 12. Phase 2 Completion Criteria
+
+Phase 2 is considered complete when:
+
+- All Phase 2 sub-phases have passed their control moments
+- No cross-phase leakage of logic exists
+- Enable/disable integration behaviour is respected
+- Functional behaviour matches the approved design exactly
+
+---
+
+End of Phase 2 implementation document.
+
diff --git a/docs/changelog.md b/docs/changelog.md
index 7c8a16a..9ed55d6 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -152,6 +152,17 @@ Changes:
 - Added proper ticket association to Job Details, matching the behaviour of manually entered tickets.
 - Updated the Run Checks view to show the ticket indicator when an Autotask ticket is linked to a run.
 
+## v20260116-04-runchecks-autotask-ticket-polling
+
+### Changes:
+- Added read-only Autotask ticket polling triggered on Run Checks page load
+- Introduced backend endpoint to poll only relevant active Autotask tickets linked to visible runs
+- Implemented ticket ID deduplication to minimize Autotask API calls
+- Ensured polling is best-effort and does not block Run Checks rendering
+- Added client support for bulk ticket queries with per-ticket fallback
+- Updated Run Checks UI to display polled PSA ticket status without modifying run state
+- Explicitly prevented any ticket mutation, resolution, or Backupchecks state changes
+
 ***
 
 ## v0.1.21

From f780bbc3998b8298b2af5971da8c218308ae1c97 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Fri, 16 Jan 2026 12:56:34 +0100
Subject: [PATCH 25/63] Auto-commit local changes before build (2026-01-16
 12:56:34)

---
 .last-branch                                  |   2 +-
 .../src/backend/app/main/routes_run_checks.py | 159 +++++-------------
 docs/changelog.md                             |   9 +
 3 files changed, 52 insertions(+), 118 deletions(-)

diff --git a/.last-branch b/.last-branch
index bb1550c..82dca39 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260116-04-runchecks-autotask-ticket-polling
+v20260116-05-autotask-ticket-create-link-all-open-runs
diff --git a/containers/backupchecks/src/backend/app/main/routes_run_checks.py b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
index 9b2c06d..c566f54 100644
--- a/containers/backupchecks/src/backend/app/main/routes_run_checks.py
+++ b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
@@ -876,110 +876,6 @@ def run_checks_details():
     return jsonify({"status": "ok", "job": job_payload, "runs": runs_payload})
 
 
-
-
-@main_bp.get("/api/run-checks/autotask-ticket-poll")
-@login_required
-@roles_required("admin", "operator")
-def api_run_checks_autotask_ticket_poll():
-    """Read-only polling of Autotask ticket state for Run Checks.
-
-    Important:
-    - No Backupchecks state is modified.
-    - No mutations are performed in Autotask.
-    - This endpoint is intended to be called only from the Run Checks page.
-    """
-
-    include_reviewed = False
-    if get_active_role() == "admin":
-        include_reviewed = request.args.get("include_reviewed", "0") in ("1", "true", "yes", "on")
-
-    # Only consider recently relevant runs to keep the payload small.
-    # We intentionally avoid unbounded history polling.
-    days = 60
-    try:
-        days = int(request.args.get("days", "60"))
-    except Exception:
-        days = 60
-    if days < 1:
-        days = 1
-    if days > 180:
-        days = 180
-
-    now_utc = datetime.utcnow().replace(tzinfo=None)
-    window_start = now_utc - timedelta(days=days)
-
-    q = JobRun.query.filter(JobRun.autotask_ticket_id.isnot(None))
-    if not include_reviewed:
-        q = q.filter(JobRun.reviewed_at.is_(None))
-
-    # Only poll runs in our time window.
-    q = q.filter(func.coalesce(JobRun.run_at, JobRun.created_at) >= window_start)
-
-    runs = (
-        q.order_by(func.coalesce(JobRun.run_at, JobRun.created_at).desc(), JobRun.id.desc())
-        .limit(400)
-        .all()
-    )
-
-    ticket_ids = []
-    seen = set()
-    for r in runs:
-        tid = getattr(r, "autotask_ticket_id", None)
-        try:
-            tid_int = int(tid)
-        except Exception:
-            continue
-        if tid_int <= 0 or tid_int in seen:
-            continue
-        seen.add(tid_int)
-        ticket_ids.append(tid_int)
-
-    if not ticket_ids:
-        return jsonify({"status": "ok", "tickets": []})
-
-    # If integration is disabled, do not fail the page.
-    settings = _get_or_create_settings()
-    if not getattr(settings, "autotask_enabled", False):
-        return jsonify({"status": "ok", "tickets": [], "autotask_enabled": False})
-
-    try:
-        client = _build_autotask_client_from_settings()
-    except Exception as exc:
-        return jsonify({"status": "ok", "tickets": [], "autotask_enabled": True, "message": str(exc)})
-
-    corr_id = datetime.utcnow().strftime("rcpoll-%Y%m%d%H%M%S")
-
-    # Query tickets in Autotask (best-effort)
-    tickets = []
-    try:
-        tickets = client.query_tickets_by_ids(ticket_ids, corr_id=corr_id)
-    except Exception:
-        tickets = []
-
-    # Build a minimal payload for UI use.
-    out = []
-    for t in tickets or []:
-        if not isinstance(t, dict):
-            continue
-        tid = t.get("id")
-        try:
-            tid_int = int(tid)
-        except Exception:
-            continue
-
-        out.append(
-            {
-                "id": tid_int,
-                "ticketNumber": (t.get("ticketNumber") or t.get("TicketNumber") or "") or "",
-                "status": t.get("status"),
-                "statusName": (t.get("statusName") or t.get("StatusName") or "") or "",
-                "title": (t.get("title") or t.get("Title") or "") or "",
-                "lastActivityDate": (t.get("lastActivityDate") or t.get("LastActivityDate") or t.get("lastActivity") or "") or "",
-            }
-        )
-
-    return jsonify({"status": "ok", "tickets": out, "autotask_enabled": True})
 @main_bp.post("/api/run-checks/autotask-ticket")
 @login_required
 @roles_required("admin", "operator")
@@ -1140,15 +1036,43 @@ def api_run_checks_create_autotask_ticket():
     except Exception:
         ticket_number = None
 
-    try:
-        run.autotask_ticket_id = int(ticket_id)
-    except Exception:
-        run.autotask_ticket_id = None
-
+    # Link the created Autotask ticket to all relevant open runs of the same job.
+    # This matches the manual ticket workflow where one ticket remains visible across runs
+    # until it is explicitly resolved.
     now = datetime.utcnow()
-    run.autotask_ticket_number = (str(ticket_number).strip() if ticket_number is not None else "") or None
-    run.autotask_ticket_created_at = now
-    run.autotask_ticket_created_by_user_id = current_user.id
+
+    linked_run_ids: list[int] = []
+    try:
+        open_runs = (
+            JobRun.query.filter(JobRun.job_id == run.job_id)
+            .filter(JobRun.reviewed_at.is_(None))
+            .order_by(JobRun.id.asc())
+            .all()
+        )
+    except Exception:
+        open_runs = [run]
+
+    # Safety: always include the explicitly selected run.
+    if run not in (open_runs or []):
+        open_runs = (open_runs or []) + [run]
+
+    for r in open_runs or []:
+        # Do not overwrite an existing (different) ticket linkage.
+        existing_id = getattr(r, "autotask_ticket_id", None)
+        if existing_id and int(existing_id) != int(ticket_id):
+            continue
+
+        try:
+            r.autotask_ticket_id = int(ticket_id)
+        except Exception:
+            r.autotask_ticket_id = None
+
+        r.autotask_ticket_number = (str(ticket_number).strip() if ticket_number is not None else "") or None
+        r.autotask_ticket_created_at = now
+        r.autotask_ticket_created_by_user_id = current_user.id
+
+        if getattr(r, "id", None):
+            linked_run_ids.append(int(r.id))
 
     # Also store an internal Ticket record and link it to the run.
     # This keeps Tickets/Remarks, Job Details, and Run Checks indicators consistent with the existing manual workflow.
@@ -1188,13 +1112,14 @@ def api_run_checks_create_autotask_ticket():
         elif scope:
             scope.resolved_at = None
 
-        # Link ticket to this job run (idempotent)
-        if internal_ticket and internal_ticket.id and run.id:
-            if not TicketJobRun.query.filter_by(ticket_id=internal_ticket.id, job_run_id=run.id).first():
-                db.session.add(TicketJobRun(ticket_id=internal_ticket.id, job_run_id=run.id, link_source="autotask"))
+        # Link ticket to all relevant job runs (idempotent)
+        for rid in linked_run_ids or []:
+            if not TicketJobRun.query.filter_by(ticket_id=internal_ticket.id, job_run_id=rid).first():
+                db.session.add(TicketJobRun(ticket_id=internal_ticket.id, job_run_id=rid, link_source="autotask"))
 
     try:
-        db.session.add(run)
+        for r in open_runs or []:
+            db.session.add(r)
         db.session.commit()
     except Exception as exc:
         db.session.rollback()
diff --git a/docs/changelog.md b/docs/changelog.md
index 9ed55d6..a13b157 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -163,6 +163,15 @@ Changes:
 - Updated Run Checks UI to display polled PSA ticket status without modifying run state
 - Explicitly prevented any ticket mutation, resolution, or Backupchecks state changes
 
+## v20260116-05-autotask-ticket-create-link-all-open-runs
+
+### Changes:
+- Fixed Autotask ticket creation to link the newly created ticket to all relevant open runs of the same job
+- Aligned automatic ticket creation behaviour with existing manual ticket linking logic
+- Ensured ticket linkage is applied consistently across runs until the ticket is resolved
+- Prevented Phase 2.1 polling from being blocked by incomplete ticket-run associations
+- No changes made to polling logic, resolution logic, or PSA state interpretation
+
 ***
 
 ## v0.1.21

From 487f923064eb36a442ca9cc88931ba8580b5c5ba Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Fri, 16 Jan 2026 13:17:06 +0100
Subject: [PATCH 26/63] Auto-commit local changes before build (2026-01-16
 13:17:06)

---
 .last-branch                                  |   2 +-
 .../src/backend/app/main/routes_run_checks.py | 112 +++++++++++++++++-
 docs/changelog.md                             |   8 ++
 3 files changed, 119 insertions(+), 3 deletions(-)

diff --git a/.last-branch b/.last-branch
index 82dca39..071f344 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260116-05-autotask-ticket-create-link-all-open-runs
+v20260116-06-runchecks-polling-merge-fix
diff --git a/containers/backupchecks/src/backend/app/main/routes_run_checks.py b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
index c566f54..0c24fdb 100644
--- a/containers/backupchecks/src/backend/app/main/routes_run_checks.py
+++ b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
@@ -876,6 +876,110 @@ def run_checks_details():
     return jsonify({"status": "ok", "job": job_payload, "runs": runs_payload})
 
 
+
+
+@main_bp.get("/api/run-checks/autotask-ticket-poll")
+@login_required
+@roles_required("admin", "operator")
+def api_run_checks_autotask_ticket_poll():
+    """Read-only polling of Autotask ticket state for Run Checks.
+
+    Important:
+    - No Backupchecks state is modified.
+    - No mutations are performed in Autotask.
+    - This endpoint is intended to be called only from the Run Checks page.
+    """
+
+    include_reviewed = False
+    if get_active_role() == "admin":
+        include_reviewed = request.args.get("include_reviewed", "0") in ("1", "true", "yes", "on")
+
+    # Only consider recently relevant runs to keep the payload small.
+    # We intentionally avoid unbounded history polling.
+    days = 60
+    try:
+        days = int(request.args.get("days", "60"))
+    except Exception:
+        days = 60
+    if days < 1:
+        days = 1
+    if days > 180:
+        days = 180
+
+    now_utc = datetime.utcnow().replace(tzinfo=None)
+    window_start = now_utc - timedelta(days=days)
+
+    q = JobRun.query.filter(JobRun.autotask_ticket_id.isnot(None))
+    if not include_reviewed:
+        q = q.filter(JobRun.reviewed_at.is_(None))
+
+    # Only poll runs in our time window.
+    q = q.filter(func.coalesce(JobRun.run_at, JobRun.created_at) >= window_start)
+
+    runs = (
+        q.order_by(func.coalesce(JobRun.run_at, JobRun.created_at).desc(), JobRun.id.desc())
+        .limit(400)
+        .all()
+    )
+
+    ticket_ids = []
+    seen = set()
+    for r in runs:
+        tid = getattr(r, "autotask_ticket_id", None)
+        try:
+            tid_int = int(tid)
+        except Exception:
+            continue
+        if tid_int <= 0 or tid_int in seen:
+            continue
+        seen.add(tid_int)
+        ticket_ids.append(tid_int)
+
+    if not ticket_ids:
+        return jsonify({"status": "ok", "tickets": []})
+
+    # If integration is disabled, do not fail the page.
+    settings = _get_or_create_settings()
+    if not getattr(settings, "autotask_enabled", False):
+        return jsonify({"status": "ok", "tickets": [], "autotask_enabled": False})
+
+    try:
+        client = _build_autotask_client_from_settings()
+    except Exception as exc:
+        return jsonify({"status": "ok", "tickets": [], "autotask_enabled": True, "message": str(exc)})
+
+    corr_id = datetime.utcnow().strftime("rcpoll-%Y%m%d%H%M%S")
+
+    # Query tickets in Autotask (best-effort)
+    tickets = []
+    try:
+        tickets = client.query_tickets_by_ids(ticket_ids, corr_id=corr_id)
+    except Exception:
+        tickets = []
+
+    # Build a minimal payload for UI use.
+    out = []
+    for t in tickets or []:
+        if not isinstance(t, dict):
+            continue
+        tid = t.get("id")
+        try:
+            tid_int = int(tid)
+        except Exception:
+            continue
+
+        out.append(
+            {
+                "id": tid_int,
+                "ticketNumber": (t.get("ticketNumber") or t.get("TicketNumber") or "") or "",
+                "status": t.get("status"),
+                "statusName": (t.get("statusName") or t.get("StatusName") or "") or "",
+                "title": (t.get("title") or t.get("Title") or "") or "",
+                "lastActivityDate": (t.get("lastActivityDate") or t.get("LastActivityDate") or t.get("lastActivity") or "") or "",
+            }
+        )
+
+    return jsonify({"status": "ok", "tickets": out, "autotask_enabled": True})
 @main_bp.post("/api/run-checks/autotask-ticket")
 @login_required
 @roles_required("admin", "operator")
@@ -1059,8 +1163,12 @@ def api_run_checks_create_autotask_ticket():
     for r in open_runs or []:
         # Do not overwrite an existing (different) ticket linkage.
         existing_id = getattr(r, "autotask_ticket_id", None)
-        if existing_id and int(existing_id) != int(ticket_id):
-            continue
+        if existing_id:
+            try:
+                if int(existing_id) != int(ticket_id):
+                    continue
+            except Exception:
+                continue
 
         try:
             r.autotask_ticket_id = int(ticket_id)
diff --git a/docs/changelog.md b/docs/changelog.md
index a13b157..a1e0c70 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -172,6 +172,14 @@ Changes:
 - Prevented Phase 2.1 polling from being blocked by incomplete ticket-run associations
 - No changes made to polling logic, resolution logic, or PSA state interpretation
 
+## v20260116-06-runchecks-polling-merge-fix
+
+### Changes:
+- Restored Phase 2.1 read-only Autotask polling logic after ticket-creation fix overwrote Run Checks routes
+- Merged polling endpoint and UI polling trigger with updated ticket-linking behaviour
+- Ensured polled PSA ticket status is available again on the Run Checks page
+- No changes made to ticket creation logic, resolution handling, or Backupchecks run state
+
 ***
 
 ## v0.1.21

From 25d1962f7bf41ed1fd052981f70fd30ee258f7ae Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Fri, 16 Jan 2026 13:31:20 +0100
Subject: [PATCH 27/63] Auto-commit local changes before build (2026-01-16
 13:31:20)

---
 .last-branch                                  |  2 +-
 .../src/backend/app/main/routes_run_checks.py | 30 ++++++++++++++-----
 docs/changelog.md                             |  9 ++++++
 3 files changed, 33 insertions(+), 8 deletions(-)

diff --git a/.last-branch b/.last-branch
index 071f344..502f598 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260116-06-runchecks-polling-merge-fix
+v20260116-07-autotask-ticket-link-all-runs-ticketjobrun-fix
diff --git a/containers/backupchecks/src/backend/app/main/routes_run_checks.py b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
index 0c24fdb..24fbf75 100644
--- a/containers/backupchecks/src/backend/app/main/routes_run_checks.py
+++ b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
@@ -1145,20 +1145,38 @@ def api_run_checks_create_autotask_ticket():
     # until it is explicitly resolved.
     now = datetime.utcnow()
 
+    # Collect the open run IDs first (stable list), then apply updates and internal linking.
     linked_run_ids: list[int] = []
     try:
-        open_runs = (
+        rows = (
             JobRun.query.filter(JobRun.job_id == run.job_id)
             .filter(JobRun.reviewed_at.is_(None))
+            .with_entities(JobRun.id)
             .order_by(JobRun.id.asc())
             .all()
         )
+        linked_run_ids = [int(rid) for (rid,) in rows if rid is not None]
     except Exception:
-        open_runs = [run]
+        linked_run_ids = []
 
     # Safety: always include the explicitly selected run.
-    if run not in (open_runs or []):
-        open_runs = (open_runs or []) + [run]
+    try:
+        if run.id and int(run.id) not in linked_run_ids:
+            linked_run_ids.append(int(run.id))
+    except Exception:
+        pass
+
+    # Load run objects for the IDs we determined.
+    open_runs = []
+    if linked_run_ids:
+        open_runs = JobRun.query.filter(JobRun.id.in_(linked_run_ids)).all()
+    else:
+        open_runs = [run]
+        try:
+            if run.id:
+                linked_run_ids = [int(run.id)]
+        except Exception:
+            linked_run_ids = []
 
     for r in open_runs or []:
         # Do not overwrite an existing (different) ticket linkage.
@@ -1179,9 +1197,6 @@ def api_run_checks_create_autotask_ticket():
         r.autotask_ticket_created_at = now
         r.autotask_ticket_created_by_user_id = current_user.id
 
-        if getattr(r, "id", None):
-            linked_run_ids.append(int(r.id))
-
     # Also store an internal Ticket record and link it to the run.
     # This keeps Tickets/Remarks, Job Details, and Run Checks indicators consistent with the existing manual workflow.
     internal_ticket = None
@@ -1239,6 +1254,7 @@ def api_run_checks_create_autotask_ticket():
             "ticket_id": int(run.autotask_ticket_id) if run.autotask_ticket_id else None,
             "ticket_number": run.autotask_ticket_number or "",
             "already_exists": False,
+            "linked_run_ids": linked_run_ids or [],
         }
     )
 
diff --git a/docs/changelog.md b/docs/changelog.md
index a1e0c70..cf5724d 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -180,6 +180,15 @@ Changes:
 - Ensured polled PSA ticket status is available again on the Run Checks page
 - No changes made to ticket creation logic, resolution handling, or Backupchecks run state
 
+
+## v20260116-07-autotask-ticket-link-all-runs-ticketjobrun-fix
+
+### Changes:
+- Fixed Autotask ticket creation linking so the internal TicketJobRun associations are created for all relevant open runs of the same job
+- Ensured ticket numbers and ticket presence are consistently visible per run (Run Checks and Job Details), not only for the selected run
+- Made the list of runs to link deterministic by collecting run IDs first, then applying both run field updates and internal ticket linking across that stable set
+- No changes made to polling logic or PSA status interpretation
+
 ***
 
 ## v0.1.21

From ef8d12065b32185905923e0bf6b260a8125766e9 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Fri, 16 Jan 2026 13:44:34 +0100
Subject: [PATCH 28/63] Auto-commit local changes before build (2026-01-16
 13:44:34)

---
 .last-branch                                  |   2 +-
 .../src/backend/app/main/routes_run_checks.py | 138 +++++++++++++++++-
 docs/changelog.md                             |   8 +
 3 files changed, 145 insertions(+), 3 deletions(-)

diff --git a/.last-branch b/.last-branch
index 502f598..a1dfda1 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260116-07-autotask-ticket-link-all-runs-ticketjobrun-fix
+v20260116-08-autotask-ticket-backfill-ticketjobrun
diff --git a/containers/backupchecks/src/backend/app/main/routes_run_checks.py b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
index 24fbf75..61b37d6 100644
--- a/containers/backupchecks/src/backend/app/main/routes_run_checks.py
+++ b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
@@ -1000,15 +1000,149 @@ def api_run_checks_create_autotask_ticket():
     run = JobRun.query.get(run_id)
     if not run:
         return jsonify({"status": "error", "message": "Run not found."}), 404
-
-    # Idempotent: if already created, return existing linkage.
+    # Idempotent: if already created, ensure internal Ticket/JobRun links exist and return existing linkage.
     if getattr(run, "autotask_ticket_id", None):
+        linked_run_ids: list[int] = []
+        try:
+            rows = (
+                JobRun.query.filter(JobRun.job_id == run.job_id)
+                .filter(JobRun.reviewed_at.is_(None))
+                .with_entities(JobRun.id)
+                .order_by(JobRun.id.asc())
+                .all()
+            )
+            linked_run_ids = [int(rid) for (rid,) in rows if rid is not None]
+        except Exception:
+            linked_run_ids = []
+
+        # Safety: always include the explicitly selected run.
+        try:
+            if run.id and int(run.id) not in linked_run_ids:
+                linked_run_ids.append(int(run.id))
+        except Exception:
+            pass
+
+        # Best-effort: backfill internal Ticket + TicketScope + TicketJobRun links so Tickets/Remarks and Job Details stay consistent.
+        try:
+            ticket_code = (getattr(run, "autotask_ticket_number", None) or "").strip().upper()
+            if ticket_code:
+                job = Job.query.get(run.job_id)
+                customer = Customer.query.get(job.customer_id) if job and getattr(job, "customer_id", None) else None
+
+                # Compose a sensible title/description (best-effort).
+                subject = None
+                description = None
+                try:
+                    status_display = run.status or "-"
+                    try:
+                        status_display, _, _, _ov_id, _ov_reason = _apply_overrides_to_run(job, run)
+                    except Exception:
+                        status_display = run.status or "-"
+
+                    cname = getattr(customer, "name", None) or ""
+                    jname = getattr(job, "job_name", None) or ""
+                    subject = f"[Backupchecks] {cname} - {jname} - {status_display}"
+
+                    settings = _get_or_create_settings()
+                    msg = MailMessage.query.get(run.mail_message_id) if run.mail_message_id else None
+                    overall_message = (getattr(msg, "overall_message", None) or "") if msg else ""
+
+                    objects_payload: list[dict[str, str]] = []
+                    try:
+                        objs = run.objects.order_by(JobObject.object_name.asc()).all()
+                    except Exception:
+                        objs = list(run.objects or [])
+                    for o in objs or []:
+                        objects_payload.append(
+                            {
+                                "name": getattr(o, "object_name", "") or "",
+                                "type": getattr(o, "object_type", "") or "",
+                                "status": getattr(o, "status", "") or "",
+                                "error_message": getattr(o, "error_message", "") or "",
+                            }
+                        )
+
+                    if (not objects_payload) and msg:
+                        try:
+                            mos = MailObject.query.filter_by(mail_message_id=msg.id).order_by(MailObject.object_name.asc()).all()
+                        except Exception:
+                            mos = []
+                        for mo in mos or []:
+                            objects_payload.append(
+                                {
+                                    "name": getattr(mo, "object_name", "") or "",
+                                    "type": getattr(mo, "object_type", "") or "",
+                                    "status": getattr(mo, "status", "") or "",
+                                    "error_message": getattr(mo, "error_message", "") or "",
+                                }
+                            )
+
+                    description = _compose_autotask_ticket_description(
+                        settings=settings,
+                        job=job,
+                        run=run,
+                        status_display=status_display,
+                        overall_message=overall_message,
+                        objects_payload=objects_payload,
+                    )
+                except Exception:
+                    subject = subject or f"[Backupchecks] Autotask {ticket_code}"
+                    description = description or ""
+
+                internal_ticket = Ticket.query.filter_by(ticket_code=ticket_code).first()
+                if not internal_ticket:
+                    now = datetime.utcnow()
+                    internal_ticket = Ticket(
+                        ticket_code=ticket_code,
+                        title=subject,
+                        description=description or "",
+                        active_from_date=_to_amsterdam_date(run.run_at) or _to_amsterdam_date(now) or now.date(),
+                        start_date=now,
+                        resolved_at=None,
+                    )
+                    db.session.add(internal_ticket)
+                    db.session.flush()
+                else:
+                    # Keep it active if it was previously resolved globally.
+                    if internal_ticket.resolved_at is not None:
+                        internal_ticket.resolved_at = None
+
+                # Ensure a job scope exists (used by popups / job details / tickets page)
+                scope = None
+                if job and job.id and internal_ticket and internal_ticket.id:
+                    scope = TicketScope.query.filter_by(ticket_id=internal_ticket.id, scope_type="job", job_id=job.id).first()
+                if not scope and internal_ticket and internal_ticket.id:
+                    scope = TicketScope(
+                        ticket_id=internal_ticket.id,
+                        scope_type="job",
+                        customer_id=job.customer_id if job else None,
+                        backup_software=job.backup_software if job else None,
+                        backup_type=job.backup_type if job else None,
+                        job_id=job.id if job else None,
+                        job_name_match=job.job_name if job else None,
+                        job_name_match_mode="exact",
+                        resolved_at=None,
+                    )
+                    db.session.add(scope)
+                elif scope:
+                    scope.resolved_at = None
+
+                # Link ticket to all relevant job runs (idempotent)
+                for rid in linked_run_ids or []:
+                    if not TicketJobRun.query.filter_by(ticket_id=internal_ticket.id, job_run_id=rid).first():
+                        db.session.add(TicketJobRun(ticket_id=internal_ticket.id, job_run_id=rid, link_source="autotask"))
+
+                db.session.commit()
+        except Exception:
+            db.session.rollback()
+
         return jsonify(
             {
                 "status": "ok",
                 "ticket_id": int(run.autotask_ticket_id),
                 "ticket_number": getattr(run, "autotask_ticket_number", None) or "",
                 "already_exists": True,
+                "linked_run_ids": linked_run_ids or [],
             }
         )
 
diff --git a/docs/changelog.md b/docs/changelog.md
index cf5724d..957a184 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -189,6 +189,14 @@ Changes:
 - Made the list of runs to link deterministic by collecting run IDs first, then applying both run field updates and internal ticket linking across that stable set
 - No changes made to polling logic or PSA status interpretation
 
+## v20260116-08-autotask-ticket-backfill-ticketjobrun
+
+- Fixed inconsistent ticket linking when creating Autotask tickets from the Run Checks page.
+- Ensured that newly created Autotask tickets are linked to all related job runs, not only the selected run.
+- Backfilled ticket-to-run associations so tickets appear correctly in the Tickets overview.
+- Corrected Job Details visibility so open runs linked to the same ticket now display the ticket number consistently.
+- Aligned Run Checks, Tickets, and Job Details views to use the same ticket-jobrun linkage logic.
+
 ***
 
 ## v0.1.21

From 9025d70b8e0d26817a8f1fc2ec6a704f1b401f2b Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Fri, 16 Jan 2026 14:13:31 +0100
Subject: [PATCH 29/63] Auto-commit local changes before build (2026-01-16
 14:13:31)

---
 .last-branch                                  |   2 +-
 .../src/backend/app/main/routes_run_checks.py | 171 ++++++++++++++++++
 docs/changelog.md                             |   8 +
 3 files changed, 180 insertions(+), 1 deletion(-)

diff --git a/.last-branch b/.last-branch
index a1dfda1..3ef23dd 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260116-08-autotask-ticket-backfill-ticketjobrun
+v20260116-09-autotask-ticket-propagate-active-runs
diff --git a/containers/backupchecks/src/backend/app/main/routes_run_checks.py b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
index 61b37d6..a913900 100644
--- a/containers/backupchecks/src/backend/app/main/routes_run_checks.py
+++ b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
@@ -143,6 +143,148 @@ def _compose_autotask_ticket_description(
 # A run within +/- 1 hour of the inferred schedule time counts as fulfilling the slot.
 MISSED_GRACE_WINDOW = timedelta(hours=1)
 
+def _propagate_autotask_ticket_to_active_runs(job_id: int) -> None:
+    """Ensure Autotask ticket linkage is consistent across all active (unreviewed) runs of a job.
+
+    Rules:
+    - Only affects runs where reviewed_at is NULL (i.e. visible as active on Run Checks).
+    - If an active Autotask ticket exists on any run for this job, copy it to all other active runs.
+    - Keep internal Ticket + TicketScope + TicketJobRun relations in sync so Tickets/Remarks and Job Details stay consistent.
+    - Do nothing if no active ticket exists.
+
+    Best-effort: errors must never break page load.
+    """
+
+    try:
+        # Find a "source" run with an Autotask ticket among active runs.
+        source = (
+            JobRun.query.filter(JobRun.job_id == job_id)
+            .filter(JobRun.reviewed_at.is_(None))
+            .filter(JobRun.autotask_ticket_id.isnot(None))
+            .order_by(func.coalesce(JobRun.run_at, JobRun.created_at).desc(), JobRun.id.desc())
+            .first()
+        )
+        if not source:
+            return
+
+        try:
+            ticket_id = int(getattr(source, "autotask_ticket_id", None) or 0)
+        except Exception:
+            ticket_id = 0
+        if ticket_id <= 0:
+            return
+
+        ticket_number = (getattr(source, "autotask_ticket_number", None) or "").strip() or None
+
+        # Collect all active runs for this job.
+        active_runs = (
+            JobRun.query.filter(JobRun.job_id == job_id)
+            .filter(JobRun.reviewed_at.is_(None))
+            .order_by(func.coalesce(JobRun.run_at, JobRun.created_at).desc(), JobRun.id.desc())
+            .all()
+        )
+        if not active_runs:
+            return
+
+        # Update run fields (but never overwrite a different ticket).
+        changed = False
+        now = datetime.utcnow()
+        for r in active_runs:
+            existing = getattr(r, "autotask_ticket_id", None)
+            if existing is not None:
+                try:
+                    if int(existing) != int(ticket_id):
+                        continue
+                except Exception:
+                    continue
+
+            if getattr(r, "autotask_ticket_id", None) is None:
+                try:
+                    r.autotask_ticket_id = int(ticket_id)
+                    changed = True
+                except Exception:
+                    pass
+
+            # Always propagate ticket number if we have one and the run doesn't.
+            if ticket_number and not (getattr(r, "autotask_ticket_number", None) or "").strip():
+                r.autotask_ticket_number = ticket_number
+                changed = True
+
+            # Preserve created-by metadata if already present; otherwise best-effort fill.
+            if getattr(r, "autotask_ticket_created_at", None) is None:
+                r.autotask_ticket_created_at = now
+                changed = True
+
+        # Ensure internal ticket linkage when we have a ticket number.
+        if ticket_number:
+            ticket_code = ticket_number.strip().upper()
+            job = Job.query.get(job_id)
+            if job:
+                internal_ticket = Ticket.query.filter_by(ticket_code=ticket_code).first()
+                if not internal_ticket:
+                    # Minimal record; title/description may be refined elsewhere.
+                    internal_ticket = Ticket(
+                        ticket_code=ticket_code,
+                        title=f"[Backupchecks] Autotask {ticket_code}",
+                        description="",
+                        active_from_date=_to_amsterdam_date(getattr(source, "run_at", None)) or _to_amsterdam_date(now) or now.date(),
+                        start_date=now,
+                        resolved_at=None,
+                    )
+                    db.session.add(internal_ticket)
+                    db.session.flush()
+                else:
+                    # Keep it active if it was previously resolved globally.
+                    if internal_ticket.resolved_at is not None:
+                        internal_ticket.resolved_at = None
+
+
+                # If this ticket is already resolved for this job (or globally), do not propagate it to new runs.
+                if internal_ticket.resolved_at is not None:
+                    return
+
+                existing_scope = TicketScope.query.filter_by(ticket_id=internal_ticket.id, scope_type="job", job_id=job.id).first()
+                if existing_scope and existing_scope.resolved_at is not None:
+                    return
+
+                # Ensure a job scope exists.
+                scope = existing_scope
+                if not scope:
+                    scope = TicketScope(
+                        ticket_id=internal_ticket.id,
+                        scope_type="job",
+                        customer_id=job.customer_id,
+                        backup_software=job.backup_software,
+                        backup_type=job.backup_type,
+                        job_id=job.id,
+                        job_name_match=job.job_name,
+                        job_name_match_mode="exact",
+                        resolved_at=None,
+                    )
+                    db.session.add(scope)
+                else:
+                    scope.resolved_at = None
+
+                # Link ticket to all active job runs (idempotent).
+                for r in active_runs:
+                    if not TicketJobRun.query.filter_by(ticket_id=internal_ticket.id, job_run_id=r.id).first():
+                        db.session.add(TicketJobRun(ticket_id=internal_ticket.id, job_run_id=r.id, link_source="autotask"))
+
+        if changed:
+            for r in active_runs:
+                db.session.add(r)
+
+        if changed or ticket_number:
+            db.session.commit()
+
+    except Exception:
+        try:
+            db.session.rollback()
+        except Exception:
+            pass
+        return
+
+
 
 def _status_is_success(status: str | None) -> bool:
     s = (status or "").strip().lower()
@@ -529,6 +671,27 @@ def run_checks_page():
 
     rows = q.limit(2000).all()
 
+    # Ensure Autotask tickets remain visible on all active runs until the ticket is resolved.
+    # This also guarantees that newly arrived runs inherit the existing ticket while it is still open.
+    try:
+        job_ids_for_page = [int(r.job_id) for r in rows]
+        if job_ids_for_page and not include_reviewed:
+            jobs_with_autotask = (
+                db.session.query(JobRun.job_id)
+                .filter(JobRun.job_id.in_(job_ids_for_page))
+                .filter(JobRun.reviewed_at.is_(None))
+                .filter(JobRun.autotask_ticket_id.isnot(None))
+                .group_by(JobRun.job_id)
+                .all()
+            )
+            for (jid,) in jobs_with_autotask or []:
+                try:
+                    _propagate_autotask_ticket_to_active_runs(int(jid))
+                except Exception:
+                    pass
+    except Exception:
+        pass
+
     # Ensure override flags are up-to-date for the runs shown in this overview.
     # The Run Checks modal computes override status on-the-fly, but the overview
     # aggregates by persisted JobRun.override_applied. Keep those flags aligned
@@ -731,6 +894,14 @@ def run_checks_details():
 
     runs = q.order_by(func.coalesce(JobRun.run_at, JobRun.created_at).desc(), JobRun.id.desc()).limit(400).all()
 
+    # Ensure Autotask tickets are consistently linked to all active runs of this job (until resolved).
+    if not include_reviewed:
+        _propagate_autotask_ticket_to_active_runs(job.id)
+        # Re-load runs so the response reflects any propagated ticket fields immediately.
+        q2 = JobRun.query.filter(JobRun.job_id == job.id)
+        q2 = q2.filter(JobRun.reviewed_at.is_(None))
+        runs = q2.order_by(func.coalesce(JobRun.run_at, JobRun.created_at).desc(), JobRun.id.desc()).limit(400).all()
+
     runs_payload = []
     for run in runs:
         msg = MailMessage.query.get(run.mail_message_id) if run.mail_message_id else None
diff --git a/docs/changelog.md b/docs/changelog.md
index 957a184..639d00d 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -197,6 +197,14 @@ Changes:
 - Corrected Job Details visibility so open runs linked to the same ticket now display the ticket number consistently.
 - Aligned Run Checks, Tickets, and Job Details views to use the same ticket-jobrun linkage logic.
 
+## v20260116-09-autotask-ticket-propagate-active-runs
+
+- Updated ticket propagation logic so Autotask tickets are linked to all active job runs (non-Reviewed) visible on the Run Checks page.
+- Ensured ticket remarks and ticket-jobrun entries are created for each active run, not only the initially selected run.
+- Implemented automatic ticket inheritance for newly incoming runs of the same job while the ticket remains unresolved.
+- Stopped ticket propagation once the ticket or job is marked as Resolved to prevent incorrect linking to closed incidents.
+- Aligned Run Checks, Tickets overview, and Job Details to consistently reflect ticket presence across all active runs.
+
 ***
 
 ## v0.1.21

From 4def0aad46f6e529716e6295d074f23d4c06d669 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Fri, 16 Jan 2026 15:38:11 +0100
Subject: [PATCH 30/63] Auto-commit local changes before build (2026-01-16
 15:38:11)

---
 .last-branch                                  |   2 +-
 .../src/backend/app/main/routes_run_checks.py | 395 +++---------------
 2 files changed, 53 insertions(+), 344 deletions(-)

diff --git a/.last-branch b/.last-branch
index 3ef23dd..5d34faf 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260116-09-autotask-ticket-propagate-active-runs
+v20260116-10-autotask-ticket-sync-internal-ticketjobrun
diff --git a/containers/backupchecks/src/backend/app/main/routes_run_checks.py b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
index a913900..191867c 100644
--- a/containers/backupchecks/src/backend/app/main/routes_run_checks.py
+++ b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
@@ -143,148 +143,6 @@ def _compose_autotask_ticket_description(
 # A run within +/- 1 hour of the inferred schedule time counts as fulfilling the slot.
 MISSED_GRACE_WINDOW = timedelta(hours=1)
 
-def _propagate_autotask_ticket_to_active_runs(job_id: int) -> None:
-    """Ensure Autotask ticket linkage is consistent across all active (unreviewed) runs of a job.
-
-    Rules:
-    - Only affects runs where reviewed_at is NULL (i.e. visible as active on Run Checks).
-    - If an active Autotask ticket exists on any run for this job, copy it to all other active runs.
-    - Keep internal Ticket + TicketScope + TicketJobRun relations in sync so Tickets/Remarks and Job Details stay consistent.
-    - Do nothing if no active ticket exists.
-
-    Best-effort: errors must never break page load.
-    """
-
-    try:
-        # Find a "source" run with an Autotask ticket among active runs.
-        source = (
-            JobRun.query.filter(JobRun.job_id == job_id)
-            .filter(JobRun.reviewed_at.is_(None))
-            .filter(JobRun.autotask_ticket_id.isnot(None))
-            .order_by(func.coalesce(JobRun.run_at, JobRun.created_at).desc(), JobRun.id.desc())
-            .first()
-        )
-        if not source:
-            return
-
-        try:
-            ticket_id = int(getattr(source, "autotask_ticket_id", None) or 0)
-        except Exception:
-            ticket_id = 0
-        if ticket_id <= 0:
-            return
-
-        ticket_number = (getattr(source, "autotask_ticket_number", None) or "").strip() or None
-
-        # Collect all active runs for this job.
-        active_runs = (
-            JobRun.query.filter(JobRun.job_id == job_id)
-            .filter(JobRun.reviewed_at.is_(None))
-            .order_by(func.coalesce(JobRun.run_at, JobRun.created_at).desc(), JobRun.id.desc())
-            .all()
-        )
-        if not active_runs:
-            return
-
-        # Update run fields (but never overwrite a different ticket).
-        changed = False
-        now = datetime.utcnow()
-        for r in active_runs:
-            existing = getattr(r, "autotask_ticket_id", None)
-            if existing is not None:
-                try:
-                    if int(existing) != int(ticket_id):
-                        continue
-                except Exception:
-                    continue
-
-            if getattr(r, "autotask_ticket_id", None) is None:
-                try:
-                    r.autotask_ticket_id = int(ticket_id)
-                    changed = True
-                except Exception:
-                    pass
-
-            # Always propagate ticket number if we have one and the run doesn't.
-            if ticket_number and not (getattr(r, "autotask_ticket_number", None) or "").strip():
-                r.autotask_ticket_number = ticket_number
-                changed = True
-
-            # Preserve created-by metadata if already present; otherwise best-effort fill.
-            if getattr(r, "autotask_ticket_created_at", None) is None:
-                r.autotask_ticket_created_at = now
-                changed = True
-
-        # Ensure internal ticket linkage when we have a ticket number.
-        if ticket_number:
-            ticket_code = ticket_number.strip().upper()
-            job = Job.query.get(job_id)
-            if job:
-                internal_ticket = Ticket.query.filter_by(ticket_code=ticket_code).first()
-                if not internal_ticket:
-                    # Minimal record; title/description may be refined elsewhere.
-                    internal_ticket = Ticket(
-                        ticket_code=ticket_code,
-                        title=f"[Backupchecks] Autotask {ticket_code}",
-                        description="",
-                        active_from_date=_to_amsterdam_date(getattr(source, "run_at", None)) or _to_amsterdam_date(now) or now.date(),
-                        start_date=now,
-                        resolved_at=None,
-                    )
-                    db.session.add(internal_ticket)
-                    db.session.flush()
-                else:
-                    # Keep it active if it was previously resolved globally.
-                    if internal_ticket.resolved_at is not None:
-                        internal_ticket.resolved_at = None
-
-
-                # If this ticket is already resolved for this job (or globally), do not propagate it to new runs.
-                if internal_ticket.resolved_at is not None:
-                    return
-
-                existing_scope = TicketScope.query.filter_by(ticket_id=internal_ticket.id, scope_type="job", job_id=job.id).first()
-                if existing_scope and existing_scope.resolved_at is not None:
-                    return
-
-                # Ensure a job scope exists.
-                scope = existing_scope
-                if not scope:
-                    scope = TicketScope(
-                        ticket_id=internal_ticket.id,
-                        scope_type="job",
-                        customer_id=job.customer_id,
-                        backup_software=job.backup_software,
-                        backup_type=job.backup_type,
-                        job_id=job.id,
-                        job_name_match=job.job_name,
-                        job_name_match_mode="exact",
-                        resolved_at=None,
-                    )
-                    db.session.add(scope)
-                else:
-                    scope.resolved_at = None
-
-                # Link ticket to all active job runs (idempotent).
-                for r in active_runs:
-                    if not TicketJobRun.query.filter_by(ticket_id=internal_ticket.id, job_run_id=r.id).first():
-                        db.session.add(TicketJobRun(ticket_id=internal_ticket.id, job_run_id=r.id, link_source="autotask"))
-
-        if changed:
-            for r in active_runs:
-                db.session.add(r)
-
-        if changed or ticket_number:
-            db.session.commit()
-
-    except Exception:
-        try:
-            db.session.rollback()
-        except Exception:
-            pass
-        return
-
-
 
 def _status_is_success(status: str | None) -> bool:
     s = (status or "").strip().lower()
@@ -671,27 +529,6 @@ def run_checks_page():
 
     rows = q.limit(2000).all()
 
-    # Ensure Autotask tickets remain visible on all active runs until the ticket is resolved.
-    # This also guarantees that newly arrived runs inherit the existing ticket while it is still open.
-    try:
-        job_ids_for_page = [int(r.job_id) for r in rows]
-        if job_ids_for_page and not include_reviewed:
-            jobs_with_autotask = (
-                db.session.query(JobRun.job_id)
-                .filter(JobRun.job_id.in_(job_ids_for_page))
-                .filter(JobRun.reviewed_at.is_(None))
-                .filter(JobRun.autotask_ticket_id.isnot(None))
-                .group_by(JobRun.job_id)
-                .all()
-            )
-            for (jid,) in jobs_with_autotask or []:
-                try:
-                    _propagate_autotask_ticket_to_active_runs(int(jid))
-                except Exception:
-                    pass
-    except Exception:
-        pass
-
     # Ensure override flags are up-to-date for the runs shown in this overview.
     # The Run Checks modal computes override status on-the-fly, but the overview
     # aggregates by persisted JobRun.override_applied. Keep those flags aligned
@@ -894,14 +731,6 @@ def run_checks_details():
 
     runs = q.order_by(func.coalesce(JobRun.run_at, JobRun.created_at).desc(), JobRun.id.desc()).limit(400).all()
 
-    # Ensure Autotask tickets are consistently linked to all active runs of this job (until resolved).
-    if not include_reviewed:
-        _propagate_autotask_ticket_to_active_runs(job.id)
-        # Re-load runs so the response reflects any propagated ticket fields immediately.
-        q2 = JobRun.query.filter(JobRun.job_id == job.id)
-        q2 = q2.filter(JobRun.reviewed_at.is_(None))
-        runs = q2.order_by(func.coalesce(JobRun.run_at, JobRun.created_at).desc(), JobRun.id.desc()).limit(400).all()
-
     runs_payload = []
     for run in runs:
         msg = MailMessage.query.get(run.mail_message_id) if run.mail_message_id else None
@@ -1171,151 +1000,16 @@ def api_run_checks_create_autotask_ticket():
     run = JobRun.query.get(run_id)
     if not run:
         return jsonify({"status": "error", "message": "Run not found."}), 404
-    # Idempotent: if already created, ensure internal Ticket/JobRun links exist and return existing linkage.
-    if getattr(run, "autotask_ticket_id", None):
-        linked_run_ids: list[int] = []
-        try:
-            rows = (
-                JobRun.query.filter(JobRun.job_id == run.job_id)
-                .filter(JobRun.reviewed_at.is_(None))
-                .with_entities(JobRun.id)
-                .order_by(JobRun.id.asc())
-                .all()
-            )
-            linked_run_ids = [int(rid) for (rid,) in rows if rid is not None]
-        except Exception:
-            linked_run_ids = []
 
-        # Safety: always include the explicitly selected run.
-        try:
-            if run.id and int(run.id) not in linked_run_ids:
-                linked_run_ids.append(int(run.id))
-        except Exception:
-            pass
-
-        # Best-effort: backfill internal Ticket + TicketScope + TicketJobRun links so Tickets/Remarks and Job Details stay consistent.
-        try:
-            ticket_code = (getattr(run, "autotask_ticket_number", None) or "").strip().upper()
-            if ticket_code:
-                job = Job.query.get(run.job_id)
-                customer = Customer.query.get(job.customer_id) if job and getattr(job, "customer_id", None) else None
-
-                # Compose a sensible title/description (best-effort).
-                subject = None
-                description = None
-                try:
-                    status_display = run.status or "-"
-                    try:
-                        status_display, _, _, _ov_id, _ov_reason = _apply_overrides_to_run(job, run)
-                    except Exception:
-                        status_display = run.status or "-"
-
-                    cname = getattr(customer, "name", None) or ""
-                    jname = getattr(job, "job_name", None) or ""
-                    subject = f"[Backupchecks] {cname} - {jname} - {status_display}"
-
-                    settings = _get_or_create_settings()
-                    msg = MailMessage.query.get(run.mail_message_id) if run.mail_message_id else None
-                    overall_message = (getattr(msg, "overall_message", None) or "") if msg else ""
-
-                    objects_payload: list[dict[str, str]] = []
-                    try:
-                        objs = run.objects.order_by(JobObject.object_name.asc()).all()
-                    except Exception:
-                        objs = list(run.objects or [])
-                    for o in objs or []:
-                        objects_payload.append(
-                            {
-                                "name": getattr(o, "object_name", "") or "",
-                                "type": getattr(o, "object_type", "") or "",
-                                "status": getattr(o, "status", "") or "",
-                                "error_message": getattr(o, "error_message", "") or "",
-                            }
-                        )
-
-                    if (not objects_payload) and msg:
-                        try:
-                            mos = MailObject.query.filter_by(mail_message_id=msg.id).order_by(MailObject.object_name.asc()).all()
-                        except Exception:
-                            mos = []
-                        for mo in mos or []:
-                            objects_payload.append(
-                                {
-                                    "name": getattr(mo, "object_name", "") or "",
-                                    "type": getattr(mo, "object_type", "") or "",
-                                    "status": getattr(mo, "status", "") or "",
-                                    "error_message": getattr(mo, "error_message", "") or "",
-                                }
-                            )
-
-                    description = _compose_autotask_ticket_description(
-                        settings=settings,
-                        job=job,
-                        run=run,
-                        status_display=status_display,
-                        overall_message=overall_message,
-                        objects_payload=objects_payload,
-                    )
-                except Exception:
-                    subject = subject or f"[Backupchecks] Autotask {ticket_code}"
-                    description = description or ""
-
-                internal_ticket = Ticket.query.filter_by(ticket_code=ticket_code).first()
-                if not internal_ticket:
-                    now = datetime.utcnow()
-                    internal_ticket = Ticket(
-                        ticket_code=ticket_code,
-                        title=subject,
-                        description=description or "",
-                        active_from_date=_to_amsterdam_date(run.run_at) or _to_amsterdam_date(now) or now.date(),
-                        start_date=now,
-                        resolved_at=None,
-                    )
-                    db.session.add(internal_ticket)
-                    db.session.flush()
-                else:
-                    # Keep it active if it was previously resolved globally.
-                    if internal_ticket.resolved_at is not None:
-                        internal_ticket.resolved_at = None
-
-                # Ensure a job scope exists (used by popups / job details / tickets page)
-                scope = None
-                if job and job.id and internal_ticket and internal_ticket.id:
-                    scope = TicketScope.query.filter_by(ticket_id=internal_ticket.id, scope_type="job", job_id=job.id).first()
-                if not scope and internal_ticket and internal_ticket.id:
-                    scope = TicketScope(
-                        ticket_id=internal_ticket.id,
-                        scope_type="job",
-                        customer_id=job.customer_id if job else None,
-                        backup_software=job.backup_software if job else None,
-                        backup_type=job.backup_type if job else None,
-                        job_id=job.id if job else None,
-                        job_name_match=job.job_name if job else None,
-                        job_name_match_mode="exact",
-                        resolved_at=None,
-                    )
-                    db.session.add(scope)
-                elif scope:
-                    scope.resolved_at = None
-
-                # Link ticket to all relevant job runs (idempotent)
-                for rid in linked_run_ids or []:
-                    if not TicketJobRun.query.filter_by(ticket_id=internal_ticket.id, job_run_id=rid).first():
-                        db.session.add(TicketJobRun(ticket_id=internal_ticket.id, job_run_id=rid, link_source="autotask"))
-
-                db.session.commit()
-        except Exception:
-            db.session.rollback()
-
-        return jsonify(
-            {
-                "status": "ok",
-                "ticket_id": int(run.autotask_ticket_id),
-                "ticket_number": getattr(run, "autotask_ticket_number", None) or "",
-                "already_exists": True,
-                "linked_run_ids": linked_run_ids or [],
-            }
-        )
+    # Idempotent behavior:
+    # If the run already has an Autotask ticket linked, we still continue so we can:
+    # - propagate the linkage to all active (non-reviewed) runs of the same job
+    # - synchronize the internal Ticket + TicketJobRun records (used by Tickets/Remarks + Job Details)
+    already_exists = False
+    existing_ticket_id = getattr(run, "autotask_ticket_id", None)
+    existing_ticket_number = (getattr(run, "autotask_ticket_number", None) or "").strip() or None
+    if existing_ticket_id:
+        already_exists = True
 
     job = Job.query.get(run.job_id)
     if not job:
@@ -1416,34 +1110,48 @@ def api_run_checks_create_autotask_ticket():
 
     try:
         client = _build_autotask_client_from_settings()
-        created = client.create_ticket(payload)
     except Exception as exc:
-        return jsonify({"status": "error", "message": f"Autotask ticket creation failed: {exc}"}), 400
+        return jsonify({"status": "error", "message": f"Autotask client initialization failed: {exc}"}), 400
 
     ticket_id = None
-    if isinstance(created, dict):
-        ticket_id = created.get("id") or created.get("itemId") or created.get("ticketId")
-        try:
-            # Some wrappers return {"item": {"id": ...}}
-            if not ticket_id and isinstance(created.get("item"), dict):
-                ticket_id = created.get("item", {}).get("id")
-        except Exception:
-            pass
+    ticket_number = None
 
-    if not ticket_id:
-        return jsonify({"status": "error", "message": "Autotask did not return a ticket id."}), 400
+    if already_exists:
+        try:
+            ticket_id = int(existing_ticket_id)
+        except Exception:
+            ticket_id = None
+        ticket_number = existing_ticket_number
+    else:
+        try:
+            created = client.create_ticket(payload)
+        except Exception as exc:
+            return jsonify({"status": "error", "message": f"Autotask ticket creation failed: {exc}"}), 400
+
+        if isinstance(created, dict):
+            ticket_id = created.get("id") or created.get("itemId") or created.get("ticketId")
+            try:
+                # Some wrappers return {"item": {"id": ...}}
+                if not ticket_id and isinstance(created.get("item"), dict):
+                    ticket_id = created.get("item", {}).get("id")
+            except Exception:
+                pass
+
+        if not ticket_id:
+            return jsonify({"status": "error", "message": "Autotask did not return a ticket id."}), 400
 
     # Autotask typically does not return the ticket number on create.
-    # Always fetch the created ticket so we can persist the ticketNumber for UI and internal linking.
-    ticket_number = None
-    try:
-        fetched = client.get_ticket(int(ticket_id))
-        if isinstance(fetched, dict) and isinstance(fetched.get("item"), dict):
-            fetched = fetched.get("item")
-        if isinstance(fetched, dict):
-            ticket_number = fetched.get("ticketNumber") or fetched.get("number") or fetched.get("ticket_number")
-    except Exception:
-        ticket_number = None
+    # Also, existing linkages may have ticket_id but no ticket_number yet.
+    # Always fetch the ticket if we don't have the number so we can persist it for UI and internal linking.
+    if ticket_id and not ticket_number:
+        try:
+            fetched = client.get_ticket(int(ticket_id))
+            if isinstance(fetched, dict) and isinstance(fetched.get("item"), dict):
+                fetched = fetched.get("item")
+            if isinstance(fetched, dict):
+                ticket_number = fetched.get("ticketNumber") or fetched.get("number") or fetched.get("ticket_number")
+        except Exception:
+            ticket_number = ticket_number or None
 
     # Link the created Autotask ticket to all relevant open runs of the same job.
     # This matches the manual ticket workflow where one ticket remains visible across runs
@@ -1502,11 +1210,12 @@ def api_run_checks_create_autotask_ticket():
         r.autotask_ticket_created_at = now
         r.autotask_ticket_created_by_user_id = current_user.id
 
-    # Also store an internal Ticket record and link it to the run.
-    # This keeps Tickets/Remarks, Job Details, and Run Checks indicators consistent with the existing manual workflow.
+    # Also store an internal Ticket record and link it to all relevant active runs.
+    # This keeps Tickets/Remarks, Job Details, and Run Checks indicators consistent with the existing manual workflow,
+    # and remains functional even if PSA integration is disabled later.
     internal_ticket = None
-    if run.autotask_ticket_number:
-        ticket_code = (run.autotask_ticket_number or "").strip().upper()
+    if ticket_number:
+        ticket_code = (str(ticket_number) or "").strip().upper()
         internal_ticket = Ticket.query.filter_by(ticket_code=ticket_code).first()
         if not internal_ticket:
             internal_ticket = Ticket(
@@ -1540,7 +1249,7 @@ def api_run_checks_create_autotask_ticket():
         elif scope:
             scope.resolved_at = None
 
-        # Link ticket to all relevant job runs (idempotent)
+        # Link ticket to all relevant active job runs (idempotent)
         for rid in linked_run_ids or []:
             if not TicketJobRun.query.filter_by(ticket_id=internal_ticket.id, job_run_id=rid).first():
                 db.session.add(TicketJobRun(ticket_id=internal_ticket.id, job_run_id=rid, link_source="autotask"))
@@ -1558,7 +1267,7 @@ def api_run_checks_create_autotask_ticket():
             "status": "ok",
             "ticket_id": int(run.autotask_ticket_id) if run.autotask_ticket_id else None,
             "ticket_number": run.autotask_ticket_number or "",
-            "already_exists": False,
+            "already_exists": bool(already_exists),
             "linked_run_ids": linked_run_ids or [],
         }
     )

From 4c183657530b50455e98615691e741f1e5cd4b4e Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Fri, 16 Jan 2026 15:39:16 +0100
Subject: [PATCH 31/63] Auto-commit local changes before build (2026-01-16
 15:39:16)

---
 docs/changelog.md | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/docs/changelog.md b/docs/changelog.md
index 639d00d..2be3bbb 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -205,6 +205,15 @@ Changes:
 - Stopped ticket propagation once the ticket or job is marked as Resolved to prevent incorrect linking to closed incidents.
 - Aligned Run Checks, Tickets overview, and Job Details to consistently reflect ticket presence across all active runs.
 
+## v20260116-10-autotask-ticket-sync-internal-ticketjobrun
+
+- Aligned Autotask ticket creation with the legacy manual ticket workflow by creating or updating an internal Ticket record using the Autotask ticket number.
+- Ensured a one-to-one mapping between Autotask tickets and internal Backupchecks tickets.
+- Linked the internal Ticket to all active (non-Reviewed) job runs by creating or backfilling TicketJobRun relations.
+- Restored visibility of Autotask-created tickets in Tickets, Tickets/Remarks, and Job Details pages.
+- Implemented idempotent behavior so repeated ticket creation or re-polling does not create duplicate tickets or links.
+- Prepared the ticket model for future scenarios where Autotask integration can be disabled and tickets can be managed manually again.
+
 ***
 
 ## v0.1.21

From 46cc5b10abfb4b291752758d29f33889ea78d2fe Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Fri, 16 Jan 2026 16:15:43 +0100
Subject: [PATCH 32/63] Auto-commit local changes before build (2026-01-16
 16:15:43)

---
 .last-branch                                  |   2 +-
 .../src/backend/app/mail_importer.py          |  13 ++
 .../src/backend/app/main/routes_inbox.py      |  38 ++++
 .../src/backend/app/main/routes_run_checks.py |  91 ++++++++-
 .../src/backend/app/ticketing_utils.py        | 189 ++++++++++++++++++
 docs/changelog.md                             |   9 +
 6 files changed, 336 insertions(+), 6 deletions(-)
 create mode 100644 containers/backupchecks/src/backend/app/ticketing_utils.py

diff --git a/.last-branch b/.last-branch
index 5d34faf..5f6e439 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260116-10-autotask-ticket-sync-internal-ticketjobrun
+v20260116-11-autotask-ticket-sync-legacy
diff --git a/containers/backupchecks/src/backend/app/mail_importer.py b/containers/backupchecks/src/backend/app/mail_importer.py
index d2479c7..3867d81 100644
--- a/containers/backupchecks/src/backend/app/mail_importer.py
+++ b/containers/backupchecks/src/backend/app/mail_importer.py
@@ -16,6 +16,7 @@ from .parsers import parse_mail_message
 from .parsers.veeam import extract_vspc_active_alarms_companies
 from .email_utils import normalize_from_address, extract_best_html_from_eml, is_effectively_blank_html
 from .job_matching import find_matching_job
+from .ticketing_utils import link_open_internal_tickets_to_run
 
 
 GRAPH_TOKEN_URL_TEMPLATE = "https://login.microsoftonline.com/{tenant_id}/oauth2/v2.0/token"
@@ -334,6 +335,12 @@ def _store_messages(settings: SystemSettings, messages):
                             db.session.add(run)
                             db.session.flush()
 
+                            # Legacy ticket behavior: inherit any open internal tickets for this job.
+                            try:
+                                link_open_internal_tickets_to_run(run=run, job=job)
+                            except Exception:
+                                pass
+
                             auto_approved_runs.append((job.customer_id, job.id, run.id, mail.id))
                             created_any = True
 
@@ -384,6 +391,12 @@ def _store_messages(settings: SystemSettings, messages):
                     db.session.add(run)
                     db.session.flush()  # ensure run.id is available
 
+                    # Legacy ticket behavior: inherit any open internal tickets for this job.
+                    try:
+                        link_open_internal_tickets_to_run(run=run, job=job)
+                    except Exception:
+                        pass
+
                     # Update mail message to reflect approval
                     mail.job_id = job.id
                     if hasattr(mail, "approved"):
diff --git a/containers/backupchecks/src/backend/app/main/routes_inbox.py b/containers/backupchecks/src/backend/app/main/routes_inbox.py
index 5ed206f..5c074d1 100644
--- a/containers/backupchecks/src/backend/app/main/routes_inbox.py
+++ b/containers/backupchecks/src/backend/app/main/routes_inbox.py
@@ -4,6 +4,7 @@ from .routes_shared import _format_datetime, _log_admin_event, _send_mail_messag
 from ..email_utils import extract_best_html_from_eml, is_effectively_blank_html
 from ..parsers.veeam import extract_vspc_active_alarms_companies
 from ..models import MailObject
+from ..ticketing_utils import link_open_internal_tickets_to_run
 
 import time
 import re
@@ -295,6 +296,13 @@ def inbox_message_approve(message_id: int):
         run.storage_free_percent = msg.storage_free_percent
     db.session.add(run)
 
+    # Legacy ticket behavior: inherit any open internal tickets for this job.
+    try:
+        db.session.flush()  # ensure run.id is available
+        link_open_internal_tickets_to_run(run=run, job=job)
+    except Exception:
+        pass
+
     # Update mail message to reflect approval
     msg.job_id = job.id
     if hasattr(msg, "approved"):
@@ -538,6 +546,12 @@ def inbox_message_approve_vspc_companies(message_id: int):
 
             db.session.add(run)
             db.session.flush()
+
+            # Legacy ticket behavior: inherit any open internal tickets for this job.
+            try:
+                link_open_internal_tickets_to_run(run=run, job=job)
+            except Exception:
+                pass
             created_runs.append(run)
 
         # Persist objects for reporting (idempotent upsert; safe to repeat).
@@ -685,6 +699,12 @@ def inbox_message_approve_vspc_companies(message_id: int):
                         db.session.add(run2)
                         db.session.flush()
 
+                        # Legacy ticket behavior: inherit any open internal tickets for this job.
+                        try:
+                            link_open_internal_tickets_to_run(run=run2, job=job2)
+                        except Exception:
+                            pass
+
                     # Persist objects per company
                     try:
                         persist_objects_for_approved_run_filtered(
@@ -1050,6 +1070,12 @@ def inbox_reparse_all():
 
                                     db.session.add(run)
                                     db.session.flush()
+
+                                    # Legacy ticket behavior: inherit any open internal tickets for this job.
+                                    try:
+                                        link_open_internal_tickets_to_run(run=run, job=job)
+                                    except Exception:
+                                        pass
                                     auto_approved_runs.append((job.customer_id, job.id, run.id, msg.id))
                                     created_any = True
 
@@ -1110,6 +1136,12 @@ def inbox_reparse_all():
 
                             db.session.add(run)
                             db.session.flush()  # ensure run.id is available
+
+                            # Legacy ticket behavior: inherit any open internal tickets for this job.
+                            try:
+                                link_open_internal_tickets_to_run(run=run, job=job)
+                            except Exception:
+                                pass
                             auto_approved_runs.append((job.customer_id, job.id, run.id, msg.id))
 
                             msg.job_id = job.id
@@ -1209,6 +1241,12 @@ def inbox_reparse_all():
 
                     db.session.add(run)
                     db.session.flush()
+
+                    # Legacy ticket behavior: inherit any open internal tickets for this job.
+                    try:
+                        link_open_internal_tickets_to_run(run=run, job=job)
+                    except Exception:
+                        pass
                     auto_approved_runs.append((job.customer_id, job.id, run.id, msg.id))
 
                     msg.job_id = job.id
diff --git a/containers/backupchecks/src/backend/app/main/routes_run_checks.py b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
index 191867c..830ce87 100644
--- a/containers/backupchecks/src/backend/app/main/routes_run_checks.py
+++ b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
@@ -39,6 +39,12 @@ from ..models import (
     User,
 )
 
+from ..ticketing_utils import (
+    ensure_internal_ticket_for_job,
+    ensure_ticket_jobrun_links,
+    link_open_internal_tickets_to_run,
+)
+
 
 def _build_autotask_client_from_settings():
     """Build an AutotaskClient from stored settings or raise a user-safe exception."""
@@ -310,6 +316,11 @@ def _ensure_missed_runs_for_job(job: Job, start_from: date, end_inclusive: date)
                 mail_message_id=None,
             )
             db.session.add(miss)
+            try:
+                db.session.flush()  # ensure miss.id is available
+                link_open_internal_tickets_to_run(run=miss, job=job)
+            except Exception:
+                pass
             inserted += 1
 
         d = d + timedelta(days=1)
@@ -391,6 +402,11 @@ def _ensure_missed_runs_for_job(job: Job, start_from: date, end_inclusive: date)
                             mail_message_id=None,
                         )
                         db.session.add(miss)
+                        try:
+                            db.session.flush()  # ensure miss.id is available
+                            link_open_internal_tickets_to_run(run=miss, job=job)
+                        except Exception:
+                            pass
                         inserted += 1
 
                 # Next month
@@ -882,12 +898,13 @@ def run_checks_details():
 @login_required
 @roles_required("admin", "operator")
 def api_run_checks_autotask_ticket_poll():
-    """Read-only polling of Autotask ticket state for Run Checks.
+    """Poll Autotask ticket state for Run Checks.
 
-    Important:
-    - No Backupchecks state is modified.
-    - No mutations are performed in Autotask.
-    - This endpoint is intended to be called only from the Run Checks page.
+    Notes:
+    - This endpoint does not mutate Autotask.
+    - As part of the legacy ticket workflow restoration, it may backfill
+      missing local metadata (ticket numbers) and internal Ticket/TicketJobRun
+      relations when those are absent.
     """
 
     include_reviewed = False
@@ -979,6 +996,70 @@ def api_run_checks_autotask_ticket_poll():
             }
         )
 
+    # Backfill local ticket numbers and internal Ticket/TicketJobRun records when missing.
+    # This is intentionally best-effort and must not break the Run Checks page.
+    try:
+        id_to_number = {}
+        id_to_title = {}
+        for item in out:
+            tid = item.get("id")
+            num = (item.get("ticketNumber") or "").strip()
+            if tid and num:
+                id_to_number[int(tid)] = num
+                id_to_title[int(tid)] = (item.get("title") or "").strip() or None
+
+        if id_to_number:
+            # Update JobRun.autotask_ticket_number if empty, and ensure internal ticket workflow exists.
+            jobs_seen = set()
+            for r in runs:
+                try:
+                    tid = int(getattr(r, "autotask_ticket_id", None) or 0)
+                except Exception:
+                    tid = 0
+                if tid <= 0 or tid not in id_to_number:
+                    continue
+
+                number = id_to_number.get(tid)
+                if number and not ((getattr(r, "autotask_ticket_number", None) or "").strip()):
+                    r.autotask_ticket_number = number
+                    db.session.add(r)
+
+                # Ensure internal Ticket + scope + links exist (per job)
+                if r.job_id and int(r.job_id) not in jobs_seen:
+                    jobs_seen.add(int(r.job_id))
+                    job = Job.query.get(r.job_id)
+                    if not job:
+                        continue
+
+                    ticket = ensure_internal_ticket_for_job(
+                        ticket_code=number,
+                        title=id_to_title.get(tid),
+                        description=f"Autotask ticket {number}",
+                        job=job,
+                        active_from_dt=getattr(r, "run_at", None),
+                        start_dt=datetime.utcnow(),
+                    )
+
+                    # Link all currently active (unreviewed) runs for this job.
+                    run_ids = [
+                        int(x)
+                        for (x,) in (
+                            JobRun.query.filter(JobRun.job_id == job.id)
+                            .filter(JobRun.reviewed_at.is_(None))
+                            .with_entities(JobRun.id)
+                            .all()
+                        )
+                        if x is not None
+                    ]
+                    ensure_ticket_jobrun_links(ticket_id=ticket.id, run_ids=run_ids, link_source="autotask")
+
+            db.session.commit()
+    except Exception:
+        try:
+            db.session.rollback()
+        except Exception:
+            pass
+
     return jsonify({"status": "ok", "tickets": out, "autotask_enabled": True})
 @main_bp.post("/api/run-checks/autotask-ticket")
 @login_required
diff --git a/containers/backupchecks/src/backend/app/ticketing_utils.py b/containers/backupchecks/src/backend/app/ticketing_utils.py
new file mode 100644
index 0000000..02b8aed
--- /dev/null
+++ b/containers/backupchecks/src/backend/app/ticketing_utils.py
@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Iterable, Optional
+
+from sqlalchemy import text
+
+from .database import db
+from .models import Job, JobRun, Ticket, TicketJobRun, TicketScope
+from .main.routes_shared import _get_ui_timezone_name, _to_amsterdam_date
+
+
+def ensure_internal_ticket_for_job(
+    *,
+    ticket_code: str,
+    title: Optional[str],
+    description: str,
+    job: Job,
+    active_from_dt: Optional[datetime],
+    start_dt: Optional[datetime] = None,
+) -> Ticket:
+    """Create/reuse an internal Ticket and ensure a job scope exists.
+
+    This mirrors the legacy manual ticket workflow but allows arbitrary ticket codes
+    (e.g. Autotask ticket numbers).
+    """
+
+    now = datetime.utcnow()
+    start_dt = start_dt or now
+
+    code = (ticket_code or "").strip().upper()
+    if not code:
+        raise ValueError("ticket_code is required")
+
+    ticket = Ticket.query.filter_by(ticket_code=code).first()
+    if not ticket:
+        ticket = Ticket(
+            ticket_code=code,
+            title=title,
+            description=description,
+            active_from_date=_to_amsterdam_date(active_from_dt) or _to_amsterdam_date(start_dt) or start_dt.date(),
+            start_date=start_dt,
+            resolved_at=None,
+        )
+        db.session.add(ticket)
+        db.session.flush()
+
+    # Ensure an open job scope exists
+    scope = TicketScope.query.filter_by(ticket_id=ticket.id, scope_type="job", job_id=job.id).first()
+    if not scope:
+        scope = TicketScope(
+            ticket_id=ticket.id,
+            scope_type="job",
+            customer_id=job.customer_id,
+            backup_software=job.backup_software,
+            backup_type=job.backup_type,
+            job_id=job.id,
+            job_name_match=job.job_name,
+            job_name_match_mode="exact",
+            resolved_at=None,
+        )
+        db.session.add(scope)
+    else:
+        # Re-open and refresh scope metadata (legacy behavior)
+        scope.resolved_at = None
+        scope.customer_id = job.customer_id
+        scope.backup_software = job.backup_software
+        scope.backup_type = job.backup_type
+        scope.job_name_match = job.job_name
+        scope.job_name_match_mode = "exact"
+
+    return ticket
+
+
+def ensure_ticket_jobrun_links(
+    *,
+    ticket_id: int,
+    run_ids: Iterable[int],
+    link_source: str,
+) -> None:
+    """Idempotently ensure TicketJobRun links exist for all provided run IDs."""
+
+    run_ids_list = [int(x) for x in (run_ids or []) if x is not None]
+    if not run_ids_list:
+        return
+
+    existing = set()
+    try:
+        rows = (
+            db.session.execute(
+                text(
+                    """
+                    SELECT job_run_id
+                    FROM ticket_job_runs
+                    WHERE ticket_id = :ticket_id
+                      AND job_run_id = ANY(:run_ids)
+                    """
+                ),
+                {"ticket_id": int(ticket_id), "run_ids": run_ids_list},
+            )
+            .fetchall()
+        )
+        existing = {int(rid) for (rid,) in rows if rid is not None}
+    except Exception:
+        existing = set()
+
+    for rid in run_ids_list:
+        if rid in existing:
+            continue
+        db.session.add(TicketJobRun(ticket_id=int(ticket_id), job_run_id=int(rid), link_source=link_source))
+
+
+def link_open_internal_tickets_to_run(*, run: JobRun, job: Job) -> None:
+    """When a new run is created, link any currently open internal tickets for the job.
+
+    This restores legacy behavior where a ticket stays visible for new runs until resolved.
+    Additionally (best-effort), if the job already has Autotask linkage on previous runs,
+    propagate that to the new run so PSA polling remains consistent.
+    """
+
+    if not run or not getattr(run, "id", None) or not job or not getattr(job, "id", None):
+        return
+
+    ui_tz = _get_ui_timezone_name()
+    run_date = _to_amsterdam_date(getattr(run, "run_at", None)) or _to_amsterdam_date(datetime.utcnow())
+
+    # Find open tickets scoped to this job for the run date window.
+    # This matches the logic used by Job Details and Run Checks indicators.
+    rows = []
+    try:
+        rows = (
+            db.session.execute(
+                text(
+                    """
+                    SELECT t.id, t.ticket_code
+                    FROM tickets t
+                    JOIN ticket_scopes ts ON ts.ticket_id = t.id
+                    WHERE ts.job_id = :job_id
+                      AND t.active_from_date <= :run_date
+                      AND (
+                        COALESCE(ts.resolved_at, t.resolved_at) IS NULL
+                        OR ((COALESCE(ts.resolved_at, t.resolved_at) AT TIME ZONE 'UTC' AT TIME ZONE :ui_tz)::date) >= :run_date
+                      )
+                    ORDER BY t.start_date DESC, t.id DESC
+                    """
+                ),
+                {"job_id": int(job.id), "run_date": run_date, "ui_tz": ui_tz},
+            )
+            .fetchall()
+        )
+    except Exception:
+        rows = []
+
+    if not rows:
+        return
+
+    # Link all open tickets to this run (idempotent)
+    for tid, _code in rows:
+        if not TicketJobRun.query.filter_by(ticket_id=int(tid), job_run_id=int(run.id)).first():
+            db.session.add(TicketJobRun(ticket_id=int(tid), job_run_id=int(run.id), link_source="inherit"))
+
+    # Best-effort: propagate Autotask linkage if present on prior runs for the same ticket code.
+    # This allows new runs to keep the PSA ticket reference without requiring UI changes.
+    try:
+        if getattr(run, "autotask_ticket_id", None):
+            return
+    except Exception:
+        pass
+
+    try:
+        # Use the newest ticket code to find a matching prior Autotask-linked run.
+        newest_code = (rows[0][1] or "").strip()
+        if not newest_code:
+            return
+
+        prior = (
+            JobRun.query.filter(JobRun.job_id == job.id)
+            .filter(JobRun.autotask_ticket_id.isnot(None))
+            .filter(JobRun.autotask_ticket_number == newest_code)
+            .order_by(JobRun.id.desc())
+            .first()
+        )
+        if prior and getattr(prior, "autotask_ticket_id", None):
+            run.autotask_ticket_id = prior.autotask_ticket_id
+            run.autotask_ticket_number = prior.autotask_ticket_number
+            run.autotask_ticket_created_at = getattr(prior, "autotask_ticket_created_at", None)
+            run.autotask_ticket_created_by_user_id = getattr(prior, "autotask_ticket_created_by_user_id", None)
+    except Exception:
+        return
diff --git a/docs/changelog.md b/docs/changelog.md
index 2be3bbb..d7a846d 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -214,6 +214,15 @@ Changes:
 - Implemented idempotent behavior so repeated ticket creation or re-polling does not create duplicate tickets or links.
 - Prepared the ticket model for future scenarios where Autotask integration can be disabled and tickets can be managed manually again.
 
+## v20260116-11-autotask-ticket-sync-legacy
+
+- Restored legacy internal ticket workflow for Autotask-created tickets by ensuring internal Ticket records are created when missing.
+- Implemented automatic creation and linking of TicketJobRun records for all active job_runs (reviewed_at IS NULL) that already contain Autotask ticket data.
+- Ensured 1:1 mapping between an Autotask ticket and a single internal Ticket, identical to manual ticket behavior.
+- Added inheritance logic so newly created job_runs automatically link to an existing open internal Ticket until it is resolved.
+- Aligned Autotask ticket creation and polling paths with the legacy manual ticket creation flow, without changing any UI behavior.
+- Ensured solution works consistently with Autotask integration enabled or disabled by relying exclusively on internal Ticket and TicketJobRun structures.
+
 ***
 
 ## v0.1.21

From f8a57efee0585da3f660d292b274313182b885fc Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Fri, 16 Jan 2026 16:24:35 +0100
Subject: [PATCH 33/63] Auto-commit local changes before build (2026-01-16
 16:24:35)

---
 .last-branch                                  |  2 +-
 .../src/backend/app/ticketing_utils.py        | 56 +++++++++++++++++--
 2 files changed, 52 insertions(+), 6 deletions(-)

diff --git a/.last-branch b/.last-branch
index 5f6e439..37b5b86 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260116-11-autotask-ticket-sync-legacy
+v20260116-12-autotask-ticket-sync-circular-import-fix
diff --git a/containers/backupchecks/src/backend/app/ticketing_utils.py b/containers/backupchecks/src/backend/app/ticketing_utils.py
index 02b8aed..23557c6 100644
--- a/containers/backupchecks/src/backend/app/ticketing_utils.py
+++ b/containers/backupchecks/src/backend/app/ticketing_utils.py
@@ -1,13 +1,59 @@
 from __future__ import annotations
 
-from datetime import datetime
+from datetime import datetime, date, timezone
 from typing import Iterable, Optional
 
+from zoneinfo import ZoneInfo
+
+from flask import current_app
+
 from sqlalchemy import text
 
 from .database import db
-from .models import Job, JobRun, Ticket, TicketJobRun, TicketScope
-from .main.routes_shared import _get_ui_timezone_name, _to_amsterdam_date
+from .models import Job, JobRun, SystemSettings, Ticket, TicketJobRun, TicketScope
+
+
+def _get_ui_timezone_name() -> str:
+    """Return the configured UI timezone name (IANA), with a safe fallback.
+
+    NOTE: This must not import from any routes_* modules to avoid circular imports.
+    """
+
+    try:
+        settings = SystemSettings.query.first()
+        name = (getattr(settings, "ui_timezone", None) or "").strip()
+        if name:
+            return name
+    except Exception:
+        pass
+
+    try:
+        return (current_app.config.get("TIMEZONE") or "Europe/Amsterdam").strip()
+    except Exception:
+        return "Europe/Amsterdam"
+
+
+def _to_ui_date(dt_utc_naive: datetime | None) -> date | None:
+    """Convert a naive UTC datetime to a UI-local date."""
+    if not dt_utc_naive:
+        return None
+
+    try:
+        tz = ZoneInfo(_get_ui_timezone_name())
+    except Exception:
+        tz = None
+
+    if not tz:
+        return dt_utc_naive.date()
+
+    try:
+        if dt_utc_naive.tzinfo is None:
+            dt_utc = dt_utc_naive.replace(tzinfo=timezone.utc)
+        else:
+            dt_utc = dt_utc_naive.astimezone(timezone.utc)
+        return dt_utc.astimezone(tz).date()
+    except Exception:
+        return dt_utc_naive.date()
 
 
 def ensure_internal_ticket_for_job(
@@ -38,7 +84,7 @@ def ensure_internal_ticket_for_job(
             ticket_code=code,
             title=title,
             description=description,
-            active_from_date=_to_amsterdam_date(active_from_dt) or _to_amsterdam_date(start_dt) or start_dt.date(),
+            active_from_date=_to_ui_date(active_from_dt) or _to_ui_date(start_dt) or start_dt.date(),
             start_date=start_dt,
             resolved_at=None,
         )
@@ -122,7 +168,7 @@ def link_open_internal_tickets_to_run(*, run: JobRun, job: Job) -> None:
         return
 
     ui_tz = _get_ui_timezone_name()
-    run_date = _to_amsterdam_date(getattr(run, "run_at", None)) or _to_amsterdam_date(datetime.utcnow())
+    run_date = _to_ui_date(getattr(run, "run_at", None)) or _to_ui_date(datetime.utcnow())
 
     # Find open tickets scoped to this job for the run date window.
     # This matches the logic used by Job Details and Run Checks indicators.

From 82bdebb721685044a6455cd99734ad9f6e1a5fe8 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Mon, 19 Jan 2026 11:11:08 +0100
Subject: [PATCH 34/63] Auto-commit local changes before build (2026-01-19
 11:11:08)

---
 .last-branch                                  |   2 +-
 .../app/integrations/autotask/client.py       | 401 +-----------
 .../src/backend/app/mail_importer.py          |  13 -
 .../src/backend/app/main/routes_inbox.py      |  38 --
 .../src/backend/app/main/routes_run_checks.py | 586 +-----------------
 .../src/backend/app/main/routes_settings.py   |  14 +-
 .../src/backend/app/migrations.py             |  63 --
 .../backupchecks/src/backend/app/models.py    |   9 -
 .../src/templates/main/run_checks.html        | 167 ++---
 .../src/templates/main/settings.html          |  14 +-
 10 files changed, 52 insertions(+), 1255 deletions(-)

diff --git a/.last-branch b/.last-branch
index 37b5b86..54b4e7f 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260116-12-autotask-ticket-sync-circular-import-fix
+v20260119-01-restoredto-v20260115-12-autotask-customers-refreshall-mappings
diff --git a/containers/backupchecks/src/backend/app/integrations/autotask/client.py b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
index 722955a..6aa9981 100644
--- a/containers/backupchecks/src/backend/app/integrations/autotask/client.py
+++ b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
@@ -1,16 +1,10 @@
 import json
-import logging
-import os
-import uuid
 from dataclasses import dataclass
 from typing import Any, Dict, List, Optional
 
 import requests
 
 
-logger = logging.getLogger(__name__)
-
-
 @dataclass
 class AutotaskZoneInfo:
     zone_name: str
@@ -43,29 +37,6 @@ class AutotaskClient:
         self._zone_info: Optional[AutotaskZoneInfo] = None
         self._zoneinfo_base_used: Optional[str] = None
 
-    def _debug_enabled(self) -> bool:
-        """Return True when verbose Autotask integration logging is enabled.
-
-        This is intentionally controlled via an environment variable to avoid
-        writing sensitive payloads to logs by default.
-        """
-        return str(os.getenv("BACKUPCHECKS_AUTOTASK_DEBUG", "")).strip().lower() in {
-            "1",
-            "true",
-            "yes",
-            "on",
-        }
-
-    def _safe_json_preview(self, data: Any, max_chars: int = 1200) -> str:
-        """Serialize JSON-like data for logging, truncating large payloads."""
-        try:
-            s = json.dumps(data, ensure_ascii=False, default=str)
-        except Exception:
-            s = str(data)
-        if len(s) > max_chars:
-            return s[:max_chars] + "…"
-        return s
-
     def _zoneinfo_bases(self) -> List[str]:
         """Return a list of zoneInformation base URLs to try.
 
@@ -134,20 +105,13 @@ class AutotaskClient:
             "Accept": "application/json",
         }
 
-    def _request_raw(
-        self,
-        method: str,
-        path: str,
-        params: Optional[Dict[str, Any]] = None,
-        json_body: Optional[Dict[str, Any]] = None,
-    ) -> requests.Response:
-        """Perform an Autotask REST API request and return the raw response."""
+    def _request(self, method: str, path: str, params: Optional[Dict[str, Any]] = None) -> Any:
         zone = self.get_zone_info()
         base = zone.api_url.rstrip("/")
         url = f"{base}/v1.0/{path.lstrip('/')}"
         headers = self._headers()
 
-        def do_request(use_basic_auth: bool, extra_headers: Optional[Dict[str, str]] = None) -> requests.Response:
+        def do_request(use_basic_auth: bool, extra_headers: Optional[Dict[str, str]] = None):
             h = dict(headers)
             if extra_headers:
                 h.update(extra_headers)
@@ -156,7 +120,6 @@ class AutotaskClient:
                 url=url,
                 headers=h,
                 params=params or None,
-                json=json_body if json_body is not None else None,
                 auth=(self.username, self.password) if use_basic_auth else None,
                 timeout=self.timeout_seconds,
             )
@@ -179,7 +142,8 @@ class AutotaskClient:
             raise AutotaskError(
                 "Authentication failed (HTTP 401). "
                 "Verify API Username, API Secret, and ApiIntegrationCode. "
-                f"Environment={self.environment}, ZoneInfoBase={zi_base}, ZoneApiUrl={zone.api_url}.",
+                f"Environment={self.environment}, ZoneInfoBase={zi_base}, ZoneApiUrl={zone.api_url}."
+            ,
                 status_code=401,
             )
         if resp.status_code == 403:
@@ -192,19 +156,6 @@ class AutotaskClient:
         if resp.status_code >= 400:
             raise AutotaskError(f"Autotask API error (HTTP {resp.status_code}).", status_code=resp.status_code)
 
-        return resp
-
-    def _request(
-        self,
-        method: str,
-        path: str,
-        params: Optional[Dict[str, Any]] = None,
-        json_body: Optional[Dict[str, Any]] = None,
-    ) -> Any:
-        resp = self._request_raw(method=method, path=path, params=params, json_body=json_body)
-        if not (resp.content or b""):
-            return {}
-
         try:
             return resp.json()
         except Exception as exc:
@@ -438,347 +389,3 @@ class AutotaskClient:
             raise AutotaskError("Tickets.priority metadata did not include picklist values.")
 
         return self._call_picklist_values(picklist_values)
-
-    def get_ticket_statuses(self) -> List[Dict[str, Any]]:
-        """Return Ticket Status picklist values.
-
-        We retrieve this from Tickets field metadata to avoid hardcoded status IDs.
-        """
-        return self._get_ticket_picklist_values(field_names=["status", "statusid"])
-
-    def get_ticket(self, ticket_id: int) -> Dict[str, Any]:
-        """Fetch a Ticket by ID via GET /Tickets/<id>."""
-        if not isinstance(ticket_id, int) or ticket_id <= 0:
-            raise AutotaskError("Invalid Autotask ticket id.")
-        data = self._request("GET", f"Tickets/{ticket_id}")
-        # Autotask commonly wraps single-entity GET results in an "item" object.
-        # Normalize to the entity dict so callers can access fields like "id" and
-        # "ticketNumber" without having to unwrap.
-        if isinstance(data, dict) and data:
-            if isinstance(data.get("item"), dict) and data.get("item"):
-                return data["item"]
-
-            # Some endpoints/tenants may return a list even for a single ID.
-            if isinstance(data.get("items"), list) and data.get("items"):
-                first = data.get("items")[0]
-                if isinstance(first, dict) and first:
-                    return first
-
-            return data
-        raise AutotaskError("Autotask did not return a ticket object.")
-
-    def query_tickets_by_ids(
-        self,
-        ticket_ids: List[int],
-        *,
-        max_records_per_query: int = 200,
-        corr_id: Optional[str] = None,
-    ) -> List[Dict[str, Any]]:
-        """Fetch multiple Tickets by id.
-
-        Preferred path:
-        - Use GET Tickets/query with an 'in' filter over id.
-
-        Fallback path:
-        - If the tenant does not support 'in' queries, fetch tickets individually
-          via GET Tickets/<id>.
-
-        Returns a list of ticket objects (dicts) for tickets that exist.
-        """
-
-        # Normalize ids
-        ids: List[int] = []
-        for x in ticket_ids or []:
-            try:
-                xi = int(x)
-            except Exception:
-                continue
-            if xi > 0:
-                ids.append(xi)
-
-        # De-duplicate while preserving order
-        seen = set()
-        dedup: List[int] = []
-        for xi in ids:
-            if xi in seen:
-                continue
-            seen.add(xi)
-            dedup.append(xi)
-
-        if not dedup:
-            return []
-
-        corr = corr_id or uuid.uuid4().hex[:10]
-
-        def _chunk(lst: List[int], n: int) -> List[List[int]]:
-            return [lst[i : i + n] for i in range(0, len(lst), n)]
-
-        out: List[Dict[str, Any]] = []
-
-        # Try query with op=in first (chunked)
-        try:
-            for chunk in _chunk(dedup, max(1, int(max_records_per_query))):
-                search_payload: Dict[str, Any] = {
-                    "filter": [
-                        {"op": "in", "field": "id", "value": chunk},
-                    ],
-                    "maxRecords": len(chunk),
-                }
-                params = {"search": json.dumps(search_payload)}
-                if self._debug_enabled():
-                    logger.info(
-                        "[autotask][%s] Tickets/query ids payload=%s",
-                        corr,
-                        self._safe_json_preview(search_payload, max_chars=1200),
-                    )
-                data = self._request("GET", "Tickets/query", params=params)
-                items = self._as_items_list(data)
-                for it in items:
-                    if isinstance(it, dict) and it:
-                        out.append(it)
-            return out
-        except AutotaskError as exc:
-            # Common tenant behavior: reject op=in with HTTP 400.
-            if self._debug_enabled():
-                logger.info(
-                    "[autotask][%s] Tickets/query ids op=in failed; falling back to per-ticket GET. error=%s",
-                    corr,
-                    str(exc),
-                )
-        except Exception as exc:
-            if self._debug_enabled():
-                logger.info(
-                    "[autotask][%s] Tickets/query ids unexpected error; falling back. error=%s",
-                    corr,
-                    str(exc),
-                )
-
-        # Fallback: individual GET calls (best-effort)
-        for tid in dedup:
-            try:
-                t = self.get_ticket(int(tid))
-                if isinstance(t, dict) and t:
-                    out.append(t)
-            except AutotaskError as exc:
-                # 404 -> deleted/missing ticket, ignore
-                if getattr(exc, "status_code", None) == 404:
-                    continue
-                # Any other error: continue best-effort
-                continue
-            except Exception:
-                continue
-
-        return out
-
-
-    def _lookup_created_ticket_id(
-        self,
-        tracking_identifier: str,
-        company_id: Optional[int] = None,
-        corr_id: Optional[str] = None,
-    ) -> Optional[int]:
-        """Lookup the most recently created ticket by tracking identifier.
-
-        Some Autotask tenants return an empty body and omit Location headers on
-        successful POST /Tickets calls. In that case, we must lookup the created
-        ticket deterministically via query.
-
-        We prefer filtering by CompanyID when available to reduce ambiguity.
-        """
-
-        tid = (tracking_identifier or "").strip()
-        if not tid:
-            return None
-
-        filters: List[Dict[str, Any]] = [
-            {"op": "eq", "field": "TrackingIdentifier", "value": tid},
-        ]
-        if isinstance(company_id, int) and company_id > 0:
-            filters.append({"op": "eq", "field": "CompanyID", "value": int(company_id)})
-
-        # Order by createDate desc when supported; fall back to id desc.
-        search_payload: Dict[str, Any] = {
-            "filter": filters,
-            "maxRecords": 1,
-            "orderby": [
-                {"field": "createDate", "direction": "desc"},
-                {"field": "id", "direction": "desc"},
-            ],
-        }
-
-        params = {"search": json.dumps(search_payload)}
-        if self._debug_enabled():
-            logger.info(
-                "[autotask][%s] Tickets/query lookup payload=%s",
-                corr_id or "-",
-                self._safe_json_preview(search_payload, max_chars=1200),
-            )
-
-        data = self._request("GET", "Tickets/query", params=params)
-        items = self._as_items_list(data)
-        if self._debug_enabled():
-            logger.info(
-                "[autotask][%s] Tickets/query lookup result_count=%s keys=%s",
-                corr_id or "-",
-                len(items),
-                (sorted(list(items[0].keys())) if items and isinstance(items[0], dict) else None),
-            )
-        if not items:
-            return None
-
-        first = items[0]
-        if isinstance(first, dict) and str(first.get("id") or "").isdigit():
-            return int(first["id"])
-        return None
-
-    def create_ticket(self, payload: Dict[str, Any]) -> Dict[str, Any]:
-        """Create a Ticket in Autotask.
-
-        Uses POST /Tickets.
-        Returns the created ticket object (as returned by Autotask).
-        """
-        if not isinstance(payload, dict) or not payload:
-            raise AutotaskError("Ticket payload is empty.")
-
-        corr_id = uuid.uuid4().hex[:10]
-
-        if self._debug_enabled():
-            # Avoid dumping full descriptions by default, but include key routing fields.
-            payload_keys = sorted(list(payload.keys()))
-            logger.info(
-                "[autotask][%s] POST /Tickets payload_keys=%s companyID=%s queueID=%s source=%s status=%s priority=%s trackingIdentifier=%s",
-                corr_id,
-                payload_keys,
-                payload.get("companyID") or payload.get("CompanyID") or payload.get("companyId"),
-                payload.get("queueID") or payload.get("QueueID") or payload.get("queueId"),
-                payload.get("source") or payload.get("Source") or payload.get("sourceId") or payload.get("sourceID"),
-                payload.get("status") or payload.get("Status") or payload.get("statusId") or payload.get("statusID"),
-                payload.get("priority") or payload.get("Priority"),
-                payload.get("trackingIdentifier") or payload.get("TrackingIdentifier"),
-            )
-
-        resp = self._request_raw("POST", "Tickets", json_body=payload)
-
-        if self._debug_enabled():
-            location = (resp.headers.get("Location") or resp.headers.get("location") or "").strip()
-            logger.info(
-                "[autotask][%s] POST /Tickets response http=%s content_type=%s content_length=%s location=%s",
-                corr_id,
-                resp.status_code,
-                (resp.headers.get("Content-Type") or resp.headers.get("content-type") or ""),
-                (len(resp.content or b"") if resp is not None else None),
-                location or None,
-            )
-
-        data: Any = {}
-        if resp.content:
-            try:
-                data = resp.json()
-            except Exception:
-                # Some tenants return an empty body or a non-JSON body on successful POST.
-                data = {}
-                if self._debug_enabled():
-                    # Log a short preview of the raw body to understand tenant behaviour.
-                    try:
-                        body_preview = (resp.text or "")[:600]
-                    except Exception:
-                        body_preview = ""
-                    logger.info(
-                        "[autotask][%s] POST /Tickets non-JSON body preview=%s",
-                        corr_id,
-                        body_preview,
-                    )
-
-        if self._debug_enabled():
-            logger.info(
-                "[autotask][%s] POST /Tickets parsed_json_type=%s json_preview=%s",
-                corr_id,
-                type(data).__name__,
-                self._safe_json_preview(data, max_chars=1200),
-            )
-
-        ticket_id: Optional[int] = None
-
-        # Autotask may return a lightweight create result like {"itemId": 12345}.
-        if isinstance(data, dict):
-            for key in ("itemId", "itemID", "id", "ticketId", "ticketID"):
-                if key in data and str(data.get(key) or "").isdigit():
-                    ticket_id = int(data[key])
-                    break
-
-            # Some variants wrap the created entity.
-            if ticket_id is None and "item" in data and isinstance(data.get("item"), dict):
-                item = data.get("item")
-                if "id" in item and str(item.get("id") or "").isdigit():
-                    ticket_id = int(item["id"])
-                else:
-                    return item
-
-            if ticket_id is None and "items" in data and isinstance(data.get("items"), list) and data.get("items"):
-                first = data.get("items")[0]
-                if isinstance(first, dict):
-                    if "id" in first and str(first.get("id") or "").isdigit():
-                        ticket_id = int(first["id"])
-                    else:
-                        return first
-
-        # Location header often contains the created entity URL.
-        if ticket_id is None:
-            location = (resp.headers.get("Location") or resp.headers.get("location") or "").strip()
-            if location:
-                try:
-                    last = location.rstrip("/").split("/")[-1]
-                    if last.isdigit():
-                        ticket_id = int(last)
-                except Exception:
-                    ticket_id = None
-
-        if self._debug_enabled():
-            logger.info(
-                "[autotask][%s] POST /Tickets extracted_ticket_id=%s",
-                corr_id,
-                ticket_id,
-            )
-
-        # If we have an ID, fetch the full ticket object so callers can reliably access ticketNumber etc.
-        if ticket_id is not None:
-            return self.get_ticket(ticket_id)
-
-        # Deterministic fallback: query by tracking identifier (+ company) if present.
-        tracking_identifier = (
-            payload.get("trackingIdentifier")
-            or payload.get("TrackingIdentifier")
-            or ""
-        )
-        company_id: Optional[int] = None
-        for ck in ("companyID", "companyId", "CompanyID"):
-            if str(payload.get(ck) or "").isdigit():
-                company_id = int(payload[ck])
-                break
-
-        if self._debug_enabled():
-            logger.info(
-                "[autotask][%s] fallback lookup by TrackingIdentifier=%s companyID=%s",
-                corr_id,
-                str(tracking_identifier),
-                company_id,
-            )
-
-        looked_up_id = self._lookup_created_ticket_id(
-            str(tracking_identifier),
-            company_id=company_id,
-            corr_id=corr_id,
-        )
-        if looked_up_id is not None:
-            return self.get_ticket(looked_up_id)
-
-        # Last-resort fallback: normalize first item if possible.
-        items = self._as_items_list(data)
-        if items:
-            return items[0]
-
-        raise AutotaskError(
-            "Autotask did not return a ticket id. "
-            "Ticket creation may still have succeeded. "
-            f"(HTTP {resp.status_code}, Correlation={corr_id})."
-        )
diff --git a/containers/backupchecks/src/backend/app/mail_importer.py b/containers/backupchecks/src/backend/app/mail_importer.py
index 3867d81..d2479c7 100644
--- a/containers/backupchecks/src/backend/app/mail_importer.py
+++ b/containers/backupchecks/src/backend/app/mail_importer.py
@@ -16,7 +16,6 @@ from .parsers import parse_mail_message
 from .parsers.veeam import extract_vspc_active_alarms_companies
 from .email_utils import normalize_from_address, extract_best_html_from_eml, is_effectively_blank_html
 from .job_matching import find_matching_job
-from .ticketing_utils import link_open_internal_tickets_to_run
 
 
 GRAPH_TOKEN_URL_TEMPLATE = "https://login.microsoftonline.com/{tenant_id}/oauth2/v2.0/token"
@@ -335,12 +334,6 @@ def _store_messages(settings: SystemSettings, messages):
                             db.session.add(run)
                             db.session.flush()
 
-                            # Legacy ticket behavior: inherit any open internal tickets for this job.
-                            try:
-                                link_open_internal_tickets_to_run(run=run, job=job)
-                            except Exception:
-                                pass
-
                             auto_approved_runs.append((job.customer_id, job.id, run.id, mail.id))
                             created_any = True
 
@@ -391,12 +384,6 @@ def _store_messages(settings: SystemSettings, messages):
                     db.session.add(run)
                     db.session.flush()  # ensure run.id is available
 
-                    # Legacy ticket behavior: inherit any open internal tickets for this job.
-                    try:
-                        link_open_internal_tickets_to_run(run=run, job=job)
-                    except Exception:
-                        pass
-
                     # Update mail message to reflect approval
                     mail.job_id = job.id
                     if hasattr(mail, "approved"):
diff --git a/containers/backupchecks/src/backend/app/main/routes_inbox.py b/containers/backupchecks/src/backend/app/main/routes_inbox.py
index 5c074d1..5ed206f 100644
--- a/containers/backupchecks/src/backend/app/main/routes_inbox.py
+++ b/containers/backupchecks/src/backend/app/main/routes_inbox.py
@@ -4,7 +4,6 @@ from .routes_shared import _format_datetime, _log_admin_event, _send_mail_messag
 from ..email_utils import extract_best_html_from_eml, is_effectively_blank_html
 from ..parsers.veeam import extract_vspc_active_alarms_companies
 from ..models import MailObject
-from ..ticketing_utils import link_open_internal_tickets_to_run
 
 import time
 import re
@@ -296,13 +295,6 @@ def inbox_message_approve(message_id: int):
         run.storage_free_percent = msg.storage_free_percent
     db.session.add(run)
 
-    # Legacy ticket behavior: inherit any open internal tickets for this job.
-    try:
-        db.session.flush()  # ensure run.id is available
-        link_open_internal_tickets_to_run(run=run, job=job)
-    except Exception:
-        pass
-
     # Update mail message to reflect approval
     msg.job_id = job.id
     if hasattr(msg, "approved"):
@@ -546,12 +538,6 @@ def inbox_message_approve_vspc_companies(message_id: int):
 
             db.session.add(run)
             db.session.flush()
-
-            # Legacy ticket behavior: inherit any open internal tickets for this job.
-            try:
-                link_open_internal_tickets_to_run(run=run, job=job)
-            except Exception:
-                pass
             created_runs.append(run)
 
         # Persist objects for reporting (idempotent upsert; safe to repeat).
@@ -699,12 +685,6 @@ def inbox_message_approve_vspc_companies(message_id: int):
                         db.session.add(run2)
                         db.session.flush()
 
-                        # Legacy ticket behavior: inherit any open internal tickets for this job.
-                        try:
-                            link_open_internal_tickets_to_run(run=run2, job=job2)
-                        except Exception:
-                            pass
-
                     # Persist objects per company
                     try:
                         persist_objects_for_approved_run_filtered(
@@ -1070,12 +1050,6 @@ def inbox_reparse_all():
 
                                     db.session.add(run)
                                     db.session.flush()
-
-                                    # Legacy ticket behavior: inherit any open internal tickets for this job.
-                                    try:
-                                        link_open_internal_tickets_to_run(run=run, job=job)
-                                    except Exception:
-                                        pass
                                     auto_approved_runs.append((job.customer_id, job.id, run.id, msg.id))
                                     created_any = True
 
@@ -1136,12 +1110,6 @@ def inbox_reparse_all():
 
                             db.session.add(run)
                             db.session.flush()  # ensure run.id is available
-
-                            # Legacy ticket behavior: inherit any open internal tickets for this job.
-                            try:
-                                link_open_internal_tickets_to_run(run=run, job=job)
-                            except Exception:
-                                pass
                             auto_approved_runs.append((job.customer_id, job.id, run.id, msg.id))
 
                             msg.job_id = job.id
@@ -1241,12 +1209,6 @@ def inbox_reparse_all():
 
                     db.session.add(run)
                     db.session.flush()
-
-                    # Legacy ticket behavior: inherit any open internal tickets for this job.
-                    try:
-                        link_open_internal_tickets_to_run(run=run, job=job)
-                    except Exception:
-                        pass
                     auto_approved_runs.append((job.customer_id, job.id, run.id, msg.id))
 
                     msg.job_id = job.id
diff --git a/containers/backupchecks/src/backend/app/main/routes_run_checks.py b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
index 830ce87..b073af2 100644
--- a/containers/backupchecks/src/backend/app/main/routes_run_checks.py
+++ b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
@@ -4,8 +4,7 @@ import calendar
 
 from datetime import date, datetime, time, timedelta, timezone
 
-from flask import jsonify, render_template, request, url_for
-from urllib.parse import urljoin
+from flask import jsonify, render_template, request
 from flask_login import current_user, login_required
 from sqlalchemy import and_, or_, func, text
 
@@ -32,119 +31,10 @@ from ..models import (
     JobRunReviewEvent,
     MailMessage,
     MailObject,
-    Ticket,
-    TicketJobRun,
-    TicketScope,
     Override,
     User,
 )
 
-from ..ticketing_utils import (
-    ensure_internal_ticket_for_job,
-    ensure_ticket_jobrun_links,
-    link_open_internal_tickets_to_run,
-)
-
-
-def _build_autotask_client_from_settings():
-    """Build an AutotaskClient from stored settings or raise a user-safe exception."""
-    settings = _get_or_create_settings()
-    if not getattr(settings, "autotask_enabled", False):
-        raise RuntimeError("Autotask integration is disabled.")
-
-    required = [
-        getattr(settings, "autotask_environment", None),
-        getattr(settings, "autotask_api_username", None),
-        getattr(settings, "autotask_api_password", None),
-        getattr(settings, "autotask_tracking_identifier", None),
-    ]
-    if any(not (x and str(x).strip()) for x in required):
-        raise RuntimeError("Autotask settings incomplete.")
-
-    from ..integrations.autotask.client import AutotaskClient
-
-    return AutotaskClient(
-        username=settings.autotask_api_username,
-        password=settings.autotask_api_password,
-        api_integration_code=settings.autotask_tracking_identifier,
-        environment=settings.autotask_environment,
-    )
-
-
-def _determine_autotask_severity(status_text: str | None) -> str:
-    s = (status_text or "").strip().lower()
-    if "warning" in s:
-        return "warning"
-    if "error" in s or "fail" in s:
-        return "error"
-    if "missed" in s:
-        return "error"
-    return "warning"
-
-
-def _compose_autotask_ticket_description(
-    *,
-    settings,
-    job: Job,
-    run: JobRun,
-    status_display: str,
-    overall_message: str,
-    objects_payload: list[dict[str, str]],
-) -> str:
-    tz_name = _get_ui_timezone_name() or "Europe/Amsterdam"
-    run_dt = run.run_at
-    run_at_str = _format_datetime(run_dt) if run_dt else "-"
-
-    base_url = (getattr(settings, "autotask_base_url", None) or "").strip()
-    job_rel = url_for("main.job_detail", job_id=job.id)
-    # Link to Job Details with a hint for the specific run.
-    job_link = urljoin(base_url.rstrip("/") + "/", job_rel.lstrip("/"))
-    if run.id:
-        job_link = f"{job_link}?run_id={int(run.id)}"
-
-    lines: list[str] = []
-    lines.append(f"Customer: {job.customer.name if job.customer else ''}")
-    lines.append(f"Job: {job.job_name or ''}")
-    lines.append(f"Backup: {job.backup_software or ''} / {job.backup_type or ''}")
-    lines.append(f"Run at ({tz_name}): {run_at_str}")
-    lines.append(f"Status: {status_display or ''}")
-    lines.append("")
-
-    overall_message = (overall_message or "").strip()
-    if overall_message:
-        lines.append("Summary:")
-        lines.append(overall_message)
-        lines.append("")
-        lines.append("Multiple objects reported messages. See Backupchecks for full details.")
-    else:
-        # Fallback to object-level messages with a hard limit.
-        limit = 10
-        shown = 0
-        total = 0
-        for o in objects_payload or []:
-            name = (o.get("name") or "").strip()
-            err = (o.get("error_message") or "").strip()
-            st = (o.get("status") or "").strip()
-            if not name:
-                continue
-            if not err and not st:
-                continue
-            total += 1
-            if shown >= limit:
-                continue
-            msg = err or st
-            lines.append(f"- {name}: {msg}")
-            shown += 1
-
-        if total == 0:
-            lines.append("No detailed object messages available. See Backupchecks for full details.")
-        elif total > shown:
-            lines.append(f"And {int(total - shown)} additional objects reported similar messages.")
-
-    lines.append("")
-    lines.append(f"Backupchecks details: {job_link}")
-    return "\n".join(lines).strip() + "\n"
-
 # Grace window for matching real runs to an expected schedule slot.
 # A run within +/- 1 hour of the inferred schedule time counts as fulfilling the slot.
 MISSED_GRACE_WINDOW = timedelta(hours=1)
@@ -316,11 +206,6 @@ def _ensure_missed_runs_for_job(job: Job, start_from: date, end_inclusive: date)
                 mail_message_id=None,
             )
             db.session.add(miss)
-            try:
-                db.session.flush()  # ensure miss.id is available
-                link_open_internal_tickets_to_run(run=miss, job=job)
-            except Exception:
-                pass
             inserted += 1
 
         d = d + timedelta(days=1)
@@ -402,11 +287,6 @@ def _ensure_missed_runs_for_job(job: Job, start_from: date, end_inclusive: date)
                             mail_message_id=None,
                         )
                         db.session.add(miss)
-                        try:
-                            db.session.flush()  # ensure miss.id is available
-                            link_open_internal_tickets_to_run(run=miss, job=job)
-                        except Exception:
-                            pass
                         inserted += 1
 
                 # Next month
@@ -873,8 +753,6 @@ def run_checks_details():
                 "mail": mail_meta,
                 "body_html": body_html,
                 "objects": objects_payload,
-                "autotask_ticket_id": getattr(run, "autotask_ticket_id", None),
-                "autotask_ticket_number": getattr(run, "autotask_ticket_number", None) or "",
             }
         )
 
@@ -892,468 +770,6 @@ def run_checks_details():
     return jsonify({"status": "ok", "job": job_payload, "runs": runs_payload})
 
 
-
-
-@main_bp.get("/api/run-checks/autotask-ticket-poll")
-@login_required
-@roles_required("admin", "operator")
-def api_run_checks_autotask_ticket_poll():
-    """Poll Autotask ticket state for Run Checks.
-
-    Notes:
-    - This endpoint does not mutate Autotask.
-    - As part of the legacy ticket workflow restoration, it may backfill
-      missing local metadata (ticket numbers) and internal Ticket/TicketJobRun
-      relations when those are absent.
-    """
-
-    include_reviewed = False
-    if get_active_role() == "admin":
-        include_reviewed = request.args.get("include_reviewed", "0") in ("1", "true", "yes", "on")
-
-    # Only consider recently relevant runs to keep the payload small.
-    # We intentionally avoid unbounded history polling.
-    days = 60
-    try:
-        days = int(request.args.get("days", "60"))
-    except Exception:
-        days = 60
-    if days < 1:
-        days = 1
-    if days > 180:
-        days = 180
-
-    now_utc = datetime.utcnow().replace(tzinfo=None)
-    window_start = now_utc - timedelta(days=days)
-
-    q = JobRun.query.filter(JobRun.autotask_ticket_id.isnot(None))
-    if not include_reviewed:
-        q = q.filter(JobRun.reviewed_at.is_(None))
-
-    # Only poll runs in our time window.
-    q = q.filter(func.coalesce(JobRun.run_at, JobRun.created_at) >= window_start)
-
-    runs = (
-        q.order_by(func.coalesce(JobRun.run_at, JobRun.created_at).desc(), JobRun.id.desc())
-        .limit(400)
-        .all()
-    )
-
-    ticket_ids = []
-    seen = set()
-    for r in runs:
-        tid = getattr(r, "autotask_ticket_id", None)
-        try:
-            tid_int = int(tid)
-        except Exception:
-            continue
-        if tid_int <= 0 or tid_int in seen:
-            continue
-        seen.add(tid_int)
-        ticket_ids.append(tid_int)
-
-    if not ticket_ids:
-        return jsonify({"status": "ok", "tickets": []})
-
-    # If integration is disabled, do not fail the page.
-    settings = _get_or_create_settings()
-    if not getattr(settings, "autotask_enabled", False):
-        return jsonify({"status": "ok", "tickets": [], "autotask_enabled": False})
-
-    try:
-        client = _build_autotask_client_from_settings()
-    except Exception as exc:
-        return jsonify({"status": "ok", "tickets": [], "autotask_enabled": True, "message": str(exc)})
-
-    corr_id = datetime.utcnow().strftime("rcpoll-%Y%m%d%H%M%S")
-
-    # Query tickets in Autotask (best-effort)
-    tickets = []
-    try:
-        tickets = client.query_tickets_by_ids(ticket_ids, corr_id=corr_id)
-    except Exception:
-        tickets = []
-
-    # Build a minimal payload for UI use.
-    out = []
-    for t in tickets or []:
-        if not isinstance(t, dict):
-            continue
-        tid = t.get("id")
-        try:
-            tid_int = int(tid)
-        except Exception:
-            continue
-
-        out.append(
-            {
-                "id": tid_int,
-                "ticketNumber": (t.get("ticketNumber") or t.get("TicketNumber") or "") or "",
-                "status": t.get("status"),
-                "statusName": (t.get("statusName") or t.get("StatusName") or "") or "",
-                "title": (t.get("title") or t.get("Title") or "") or "",
-                "lastActivityDate": (t.get("lastActivityDate") or t.get("LastActivityDate") or t.get("lastActivity") or "") or "",
-            }
-        )
-
-    # Backfill local ticket numbers and internal Ticket/TicketJobRun records when missing.
-    # This is intentionally best-effort and must not break the Run Checks page.
-    try:
-        id_to_number = {}
-        id_to_title = {}
-        for item in out:
-            tid = item.get("id")
-            num = (item.get("ticketNumber") or "").strip()
-            if tid and num:
-                id_to_number[int(tid)] = num
-                id_to_title[int(tid)] = (item.get("title") or "").strip() or None
-
-        if id_to_number:
-            # Update JobRun.autotask_ticket_number if empty, and ensure internal ticket workflow exists.
-            jobs_seen = set()
-            for r in runs:
-                try:
-                    tid = int(getattr(r, "autotask_ticket_id", None) or 0)
-                except Exception:
-                    tid = 0
-                if tid <= 0 or tid not in id_to_number:
-                    continue
-
-                number = id_to_number.get(tid)
-                if number and not ((getattr(r, "autotask_ticket_number", None) or "").strip()):
-                    r.autotask_ticket_number = number
-                    db.session.add(r)
-
-                # Ensure internal Ticket + scope + links exist (per job)
-                if r.job_id and int(r.job_id) not in jobs_seen:
-                    jobs_seen.add(int(r.job_id))
-                    job = Job.query.get(r.job_id)
-                    if not job:
-                        continue
-
-                    ticket = ensure_internal_ticket_for_job(
-                        ticket_code=number,
-                        title=id_to_title.get(tid),
-                        description=f"Autotask ticket {number}",
-                        job=job,
-                        active_from_dt=getattr(r, "run_at", None),
-                        start_dt=datetime.utcnow(),
-                    )
-
-                    # Link all currently active (unreviewed) runs for this job.
-                    run_ids = [
-                        int(x)
-                        for (x,) in (
-                            JobRun.query.filter(JobRun.job_id == job.id)
-                            .filter(JobRun.reviewed_at.is_(None))
-                            .with_entities(JobRun.id)
-                            .all()
-                        )
-                        if x is not None
-                    ]
-                    ensure_ticket_jobrun_links(ticket_id=ticket.id, run_ids=run_ids, link_source="autotask")
-
-            db.session.commit()
-    except Exception:
-        try:
-            db.session.rollback()
-        except Exception:
-            pass
-
-    return jsonify({"status": "ok", "tickets": out, "autotask_enabled": True})
-@main_bp.post("/api/run-checks/autotask-ticket")
-@login_required
-@roles_required("admin", "operator")
-def api_run_checks_create_autotask_ticket():
-    """Create an Autotask ticket for a specific run.
-
-    Enforces: exactly one ticket per run.
-    """
-    data = request.get_json(silent=True) or {}
-    try:
-        run_id = int(data.get("run_id") or 0)
-    except Exception:
-        run_id = 0
-
-    if run_id <= 0:
-        return jsonify({"status": "error", "message": "Invalid parameters."}), 400
-
-    run = JobRun.query.get(run_id)
-    if not run:
-        return jsonify({"status": "error", "message": "Run not found."}), 404
-
-    # Idempotent behavior:
-    # If the run already has an Autotask ticket linked, we still continue so we can:
-    # - propagate the linkage to all active (non-reviewed) runs of the same job
-    # - synchronize the internal Ticket + TicketJobRun records (used by Tickets/Remarks + Job Details)
-    already_exists = False
-    existing_ticket_id = getattr(run, "autotask_ticket_id", None)
-    existing_ticket_number = (getattr(run, "autotask_ticket_number", None) or "").strip() or None
-    if existing_ticket_id:
-        already_exists = True
-
-    job = Job.query.get(run.job_id)
-    if not job:
-        return jsonify({"status": "error", "message": "Job not found."}), 404
-
-    customer = Customer.query.get(job.customer_id) if getattr(job, "customer_id", None) else None
-    if not customer:
-        return jsonify({"status": "error", "message": "Customer not found."}), 404
-
-    if not getattr(customer, "autotask_company_id", None):
-        return jsonify({"status": "error", "message": "Customer has no Autotask company mapping."}), 400
-
-    if (getattr(customer, "autotask_mapping_status", None) or "").strip().lower() not in ("ok", "renamed"):
-        return jsonify({"status": "error", "message": "Autotask company mapping is not valid."}), 400
-
-    settings = _get_or_create_settings()
-
-    base_url = (getattr(settings, "autotask_base_url", None) or "").strip()
-    if not base_url:
-        return jsonify({"status": "error", "message": "Autotask Base URL is not configured."}), 400
-
-    # Required ticket defaults
-    if not getattr(settings, "autotask_default_queue_id", None):
-        return jsonify({"status": "error", "message": "Autotask default queue is not configured."}), 400
-    if not getattr(settings, "autotask_default_ticket_source_id", None):
-        return jsonify({"status": "error", "message": "Autotask default ticket source is not configured."}), 400
-    if not getattr(settings, "autotask_default_ticket_status", None):
-        return jsonify({"status": "error", "message": "Autotask default ticket status is not configured."}), 400
-
-    # Determine display status (including overrides) for consistent subject/priority mapping.
-    status_display = run.status or "-"
-    try:
-        status_display, _, _, _ov_id, _ov_reason = _apply_overrides_to_run(job, run)
-    except Exception:
-        status_display = run.status or "-"
-
-    severity = _determine_autotask_severity(status_display)
-    priority_id = None
-    if severity == "warning":
-        priority_id = getattr(settings, "autotask_priority_warning", None)
-    else:
-        priority_id = getattr(settings, "autotask_priority_error", None)
-
-    # Load mail + objects for ticket composition.
-    msg = MailMessage.query.get(run.mail_message_id) if run.mail_message_id else None
-    overall_message = (getattr(msg, "overall_message", None) or "") if msg else ""
-
-    objects_payload: list[dict[str, str]] = []
-    try:
-        objs = run.objects.order_by(JobObject.object_name.asc()).all()
-    except Exception:
-        objs = list(run.objects or [])
-    for o in objs or []:
-        objects_payload.append(
-            {
-                "name": getattr(o, "object_name", "") or "",
-                "type": getattr(o, "object_type", "") or "",
-                "status": getattr(o, "status", "") or "",
-                "error_message": getattr(o, "error_message", "") or "",
-            }
-        )
-
-    if (not objects_payload) and msg:
-        try:
-            mos = MailObject.query.filter_by(mail_message_id=msg.id).order_by(MailObject.object_name.asc()).all()
-        except Exception:
-            mos = []
-        for mo in mos or []:
-            objects_payload.append(
-                {
-                    "name": getattr(mo, "object_name", "") or "",
-                    "type": getattr(mo, "object_type", "") or "",
-                    "status": getattr(mo, "status", "") or "",
-                    "error_message": getattr(mo, "error_message", "") or "",
-                }
-            )
-
-    subject = f"[Backupchecks] {customer.name} - {job.job_name or ''} - {status_display}"
-    description = _compose_autotask_ticket_description(
-        settings=settings,
-        job=job,
-        run=run,
-        status_display=status_display,
-        overall_message=overall_message,
-        objects_payload=objects_payload,
-    )
-
-    payload = {
-        "companyID": int(customer.autotask_company_id),
-        "title": subject,
-        "description": description,
-        "queueID": int(settings.autotask_default_queue_id),
-        "source": int(settings.autotask_default_ticket_source_id),
-        "status": int(settings.autotask_default_ticket_status),
-    }
-    if priority_id:
-        payload["priority"] = int(priority_id)
-
-    try:
-        client = _build_autotask_client_from_settings()
-    except Exception as exc:
-        return jsonify({"status": "error", "message": f"Autotask client initialization failed: {exc}"}), 400
-
-    ticket_id = None
-    ticket_number = None
-
-    if already_exists:
-        try:
-            ticket_id = int(existing_ticket_id)
-        except Exception:
-            ticket_id = None
-        ticket_number = existing_ticket_number
-    else:
-        try:
-            created = client.create_ticket(payload)
-        except Exception as exc:
-            return jsonify({"status": "error", "message": f"Autotask ticket creation failed: {exc}"}), 400
-
-        if isinstance(created, dict):
-            ticket_id = created.get("id") or created.get("itemId") or created.get("ticketId")
-            try:
-                # Some wrappers return {"item": {"id": ...}}
-                if not ticket_id and isinstance(created.get("item"), dict):
-                    ticket_id = created.get("item", {}).get("id")
-            except Exception:
-                pass
-
-        if not ticket_id:
-            return jsonify({"status": "error", "message": "Autotask did not return a ticket id."}), 400
-
-    # Autotask typically does not return the ticket number on create.
-    # Also, existing linkages may have ticket_id but no ticket_number yet.
-    # Always fetch the ticket if we don't have the number so we can persist it for UI and internal linking.
-    if ticket_id and not ticket_number:
-        try:
-            fetched = client.get_ticket(int(ticket_id))
-            if isinstance(fetched, dict) and isinstance(fetched.get("item"), dict):
-                fetched = fetched.get("item")
-            if isinstance(fetched, dict):
-                ticket_number = fetched.get("ticketNumber") or fetched.get("number") or fetched.get("ticket_number")
-        except Exception:
-            ticket_number = ticket_number or None
-
-    # Link the created Autotask ticket to all relevant open runs of the same job.
-    # This matches the manual ticket workflow where one ticket remains visible across runs
-    # until it is explicitly resolved.
-    now = datetime.utcnow()
-
-    # Collect the open run IDs first (stable list), then apply updates and internal linking.
-    linked_run_ids: list[int] = []
-    try:
-        rows = (
-            JobRun.query.filter(JobRun.job_id == run.job_id)
-            .filter(JobRun.reviewed_at.is_(None))
-            .with_entities(JobRun.id)
-            .order_by(JobRun.id.asc())
-            .all()
-        )
-        linked_run_ids = [int(rid) for (rid,) in rows if rid is not None]
-    except Exception:
-        linked_run_ids = []
-
-    # Safety: always include the explicitly selected run.
-    try:
-        if run.id and int(run.id) not in linked_run_ids:
-            linked_run_ids.append(int(run.id))
-    except Exception:
-        pass
-
-    # Load run objects for the IDs we determined.
-    open_runs = []
-    if linked_run_ids:
-        open_runs = JobRun.query.filter(JobRun.id.in_(linked_run_ids)).all()
-    else:
-        open_runs = [run]
-        try:
-            if run.id:
-                linked_run_ids = [int(run.id)]
-        except Exception:
-            linked_run_ids = []
-
-    for r in open_runs or []:
-        # Do not overwrite an existing (different) ticket linkage.
-        existing_id = getattr(r, "autotask_ticket_id", None)
-        if existing_id:
-            try:
-                if int(existing_id) != int(ticket_id):
-                    continue
-            except Exception:
-                continue
-
-        try:
-            r.autotask_ticket_id = int(ticket_id)
-        except Exception:
-            r.autotask_ticket_id = None
-
-        r.autotask_ticket_number = (str(ticket_number).strip() if ticket_number is not None else "") or None
-        r.autotask_ticket_created_at = now
-        r.autotask_ticket_created_by_user_id = current_user.id
-
-    # Also store an internal Ticket record and link it to all relevant active runs.
-    # This keeps Tickets/Remarks, Job Details, and Run Checks indicators consistent with the existing manual workflow,
-    # and remains functional even if PSA integration is disabled later.
-    internal_ticket = None
-    if ticket_number:
-        ticket_code = (str(ticket_number) or "").strip().upper()
-        internal_ticket = Ticket.query.filter_by(ticket_code=ticket_code).first()
-        if not internal_ticket:
-            internal_ticket = Ticket(
-                ticket_code=ticket_code,
-                title=subject,
-                description=description,
-                active_from_date=_to_amsterdam_date(run.run_at) or _to_amsterdam_date(now) or now.date(),
-                start_date=now,
-                resolved_at=None,
-            )
-            db.session.add(internal_ticket)
-            db.session.flush()
-
-        # Ensure a job scope exists (used by popups / job details / tickets page)
-        scope = None
-        if job and job.id and internal_ticket and internal_ticket.id:
-            scope = TicketScope.query.filter_by(ticket_id=internal_ticket.id, scope_type="job", job_id=job.id).first()
-        if not scope and internal_ticket and internal_ticket.id:
-            scope = TicketScope(
-                ticket_id=internal_ticket.id,
-                scope_type="job",
-                customer_id=job.customer_id if job else None,
-                backup_software=job.backup_software if job else None,
-                backup_type=job.backup_type if job else None,
-                job_id=job.id if job else None,
-                job_name_match=job.job_name if job else None,
-                job_name_match_mode="exact",
-                resolved_at=None,
-            )
-            db.session.add(scope)
-        elif scope:
-            scope.resolved_at = None
-
-        # Link ticket to all relevant active job runs (idempotent)
-        for rid in linked_run_ids or []:
-            if not TicketJobRun.query.filter_by(ticket_id=internal_ticket.id, job_run_id=rid).first():
-                db.session.add(TicketJobRun(ticket_id=internal_ticket.id, job_run_id=rid, link_source="autotask"))
-
-    try:
-        for r in open_runs or []:
-            db.session.add(r)
-        db.session.commit()
-    except Exception as exc:
-        db.session.rollback()
-        return jsonify({"status": "error", "message": f"Failed to store ticket reference: {exc}"}), 500
-
-    return jsonify(
-        {
-            "status": "ok",
-            "ticket_id": int(run.autotask_ticket_id) if run.autotask_ticket_id else None,
-            "ticket_number": run.autotask_ticket_number or "",
-            "already_exists": bool(already_exists),
-            "linked_run_ids": linked_run_ids or [],
-        }
-    )
-
-
 @main_bp.post("/api/run-checks/mark-reviewed")
 @login_required
 @roles_required("admin", "operator")
diff --git a/containers/backupchecks/src/backend/app/main/routes_settings.py b/containers/backupchecks/src/backend/app/main/routes_settings.py
index 2160fb5..5897121 100644
--- a/containers/backupchecks/src/backend/app/main/routes_settings.py
+++ b/containers/backupchecks/src/backend/app/main/routes_settings.py
@@ -657,7 +657,6 @@ def settings():
     autotask_queues = []
     autotask_ticket_sources = []
     autotask_priorities = []
-    autotask_ticket_statuses = []
     autotask_last_sync_at = getattr(settings, "autotask_reference_last_sync_at", None)
 
     try:
@@ -678,12 +677,6 @@ def settings():
     except Exception:
         autotask_priorities = []
 
-    try:
-        if getattr(settings, "autotask_cached_ticket_statuses_json", None):
-            autotask_ticket_statuses = json.loads(settings.autotask_cached_ticket_statuses_json) or []
-    except Exception:
-        autotask_ticket_statuses = []
-
     return render_template(
         "main/settings.html",
         settings=settings,
@@ -699,7 +692,6 @@ def settings():
         autotask_queues=autotask_queues,
         autotask_ticket_sources=autotask_ticket_sources,
         autotask_priorities=autotask_priorities,
-        autotask_ticket_statuses=autotask_ticket_statuses,
         autotask_last_sync_at=autotask_last_sync_at,
         news_admin_items=news_admin_items,
         news_admin_stats=news_admin_stats,
@@ -1330,7 +1322,6 @@ def settings_autotask_refresh_reference_data():
         queues = client.get_queues()
         sources = client.get_ticket_sources()
         priorities = client.get_ticket_priorities()
-        statuses = client.get_ticket_statuses()
 
         # Store a minimal subset for dropdowns (id + name/label)
         # Note: Some "reference" values are exposed as picklists (value/label)
@@ -1363,7 +1354,6 @@ def settings_autotask_refresh_reference_data():
 
         settings.autotask_cached_queues_json = json.dumps(_norm(queues))
         settings.autotask_cached_ticket_sources_json = json.dumps(_norm(sources))
-        settings.autotask_cached_ticket_statuses_json = json.dumps(_norm(statuses))
 
         # Priorities are returned as picklist values (value/label)
         pr_out = []
@@ -1387,13 +1377,13 @@ def settings_autotask_refresh_reference_data():
         db.session.commit()
 
         flash(
-            f"Autotask reference data refreshed. Queues: {len(queues)}. Ticket Sources: {len(sources)}. Ticket Statuses: {len(statuses)}. Priorities: {len(pr_out)}.",
+            f"Autotask reference data refreshed. Queues: {len(queues)}. Ticket Sources: {len(sources)}. Priorities: {len(pr_out)}.",
             "success",
         )
         _log_admin_event(
             "autotask_refresh_reference_data",
             "Autotask reference data refreshed.",
-            details=json.dumps({"queues": len(queues or []), "ticket_sources": len(sources or []), "ticket_statuses": len(statuses or []), "priorities": len(pr_out)}),
+            details=json.dumps({"queues": len(queues or []), "ticket_sources": len(sources or []), "priorities": len(pr_out)}),
         )
     except Exception as exc:
         flash(f"Failed to refresh Autotask reference data: {exc}", "danger")
diff --git a/containers/backupchecks/src/backend/app/migrations.py b/containers/backupchecks/src/backend/app/migrations.py
index b1d1405..6c21f5e 100644
--- a/containers/backupchecks/src/backend/app/migrations.py
+++ b/containers/backupchecks/src/backend/app/migrations.py
@@ -168,7 +168,6 @@ def migrate_system_settings_autotask_integration() -> None:
         ("autotask_cached_queues_json", "TEXT NULL"),
         ("autotask_cached_ticket_sources_json", "TEXT NULL"),
         ("autotask_cached_priorities_json", "TEXT NULL"),
-        ("autotask_cached_ticket_statuses_json", "TEXT NULL"),
         ("autotask_reference_last_sync_at", "TIMESTAMP NULL"),
     ]
 
@@ -898,7 +897,6 @@ def run_migrations() -> None:
     migrate_overrides_match_columns()
     migrate_job_runs_review_tracking()
     migrate_job_runs_override_metadata()
-    migrate_job_runs_autotask_ticket_fields()
     migrate_jobs_archiving()
     migrate_news_tables()
     migrate_reporting_tables()
@@ -906,67 +904,6 @@ def run_migrations() -> None:
     print("[migrations] All migrations completed.")
 
 
-def migrate_job_runs_autotask_ticket_fields() -> None:
-    """Add Autotask ticket linkage fields to job_runs if missing.
-
-    Columns:
-    - job_runs.autotask_ticket_id (INTEGER NULL)
-    - job_runs.autotask_ticket_number (VARCHAR(64) NULL)
-    - job_runs.autotask_ticket_created_at (TIMESTAMP NULL)
-    - job_runs.autotask_ticket_created_by_user_id (INTEGER NULL, FK users.id)
-    """
-
-    table = "job_runs"
-    try:
-        engine = db.get_engine()
-    except Exception as exc:
-        print(f"[migrations] Could not get engine for job_runs Autotask ticket migration: {exc}")
-        return
-
-    try:
-        with engine.connect() as conn:
-            cols = _get_table_columns(conn, table)
-            if not cols:
-                return
-
-            if "autotask_ticket_id" not in cols:
-                print("[migrations] Adding job_runs.autotask_ticket_id column...")
-                conn.execute(text('ALTER TABLE "job_runs" ADD COLUMN autotask_ticket_id INTEGER'))
-
-            if "autotask_ticket_number" not in cols:
-                print("[migrations] Adding job_runs.autotask_ticket_number column...")
-                conn.execute(text('ALTER TABLE "job_runs" ADD COLUMN autotask_ticket_number VARCHAR(64)'))
-
-            if "autotask_ticket_created_at" not in cols:
-                print("[migrations] Adding job_runs.autotask_ticket_created_at column...")
-                conn.execute(text('ALTER TABLE "job_runs" ADD COLUMN autotask_ticket_created_at TIMESTAMP'))
-
-            if "autotask_ticket_created_by_user_id" not in cols:
-                print("[migrations] Adding job_runs.autotask_ticket_created_by_user_id column...")
-                conn.execute(text('ALTER TABLE "job_runs" ADD COLUMN autotask_ticket_created_by_user_id INTEGER'))
-
-                try:
-                    conn.execute(
-                        text(
-                            'ALTER TABLE "job_runs" '
-                            'ADD CONSTRAINT job_runs_autotask_ticket_created_by_user_id_fkey '
-                            'FOREIGN KEY (autotask_ticket_created_by_user_id) REFERENCES users(id) '
-                            'ON DELETE SET NULL'
-                        )
-                    )
-                except Exception as exc:
-                    print(
-                        f"[migrations] Could not add FK job_runs.autotask_ticket_created_by_user_id -> users.id (continuing): {exc}"
-                    )
-
-            conn.execute(text('CREATE INDEX IF NOT EXISTS idx_job_runs_autotask_ticket_id ON "job_runs" (autotask_ticket_id)'))
-    except Exception as exc:
-        print(f"[migrations] job_runs table not found; skipping migrate_job_runs_autotask_ticket_fields: {exc}")
-        return
-
-    print("[migrations] migrate_job_runs_autotask_ticket_fields completed.")
-
-
 def migrate_jobs_archiving() -> None:
     """Add archiving columns to jobs if missing.
 
diff --git a/containers/backupchecks/src/backend/app/models.py b/containers/backupchecks/src/backend/app/models.py
index 4ecba7d..e72a846 100644
--- a/containers/backupchecks/src/backend/app/models.py
+++ b/containers/backupchecks/src/backend/app/models.py
@@ -127,7 +127,6 @@ class SystemSettings(db.Model):
     autotask_cached_queues_json = db.Column(db.Text, nullable=True)
     autotask_cached_ticket_sources_json = db.Column(db.Text, nullable=True)
     autotask_cached_priorities_json = db.Column(db.Text, nullable=True)
-    autotask_cached_ticket_statuses_json = db.Column(db.Text, nullable=True)
     autotask_reference_last_sync_at = db.Column(db.DateTime, nullable=True)
     created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
     updated_at = db.Column(
@@ -276,12 +275,6 @@ class JobRun(db.Model):
     reviewed_at = db.Column(db.DateTime, nullable=True)
     reviewed_by_user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=True)
 
-    # Autotask integration (Phase 4: ticket creation from Run Checks)
-    autotask_ticket_id = db.Column(db.Integer, nullable=True)
-    autotask_ticket_number = db.Column(db.String(64), nullable=True)
-    autotask_ticket_created_at = db.Column(db.DateTime, nullable=True)
-    autotask_ticket_created_by_user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=True)
-
 
     created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
     updated_at = db.Column(
@@ -295,8 +288,6 @@ class JobRun(db.Model):
 
     reviewed_by = db.relationship("User", foreign_keys=[reviewed_by_user_id])
 
-    autotask_ticket_created_by = db.relationship("User", foreign_keys=[autotask_ticket_created_by_user_id])
-
 
 class JobRunReviewEvent(db.Model):
     __tablename__ = "job_run_review_events"
diff --git a/containers/backupchecks/src/templates/main/run_checks.html b/containers/backupchecks/src/templates/main/run_checks.html
index be31ea8..90de7aa 100644
--- a/containers/backupchecks/src/templates/main/run_checks.html
+++ b/containers/backupchecks/src/templates/main/run_checks.html
@@ -214,16 +214,18 @@
                   <div id="rcm_alerts" class="small"></div>
                   <div class="mt-2">
                     <div class="row g-2 align-items-start">
-	                      <div class="col-12 col-lg-6">
-	                        <div class="border rounded p-2">
-	                          <div class="d-flex align-items-center justify-content-between">
-	                            <div class="fw-semibold">Autotask ticket</div>
-	                            <button type="button" class="btn btn-sm btn-outline-primary" id="rcm_autotask_create">Create</button>
-	                          </div>
-	                          <div class="mt-2 small" id="rcm_autotask_info"></div>
-	                          <div class="mt-2 small text-muted" id="rcm_autotask_status"></div>
-	                        </div>
-	                      </div>
+                      <div class="col-12 col-lg-6">
+                        <div class="border rounded p-2">
+                          <div class="d-flex align-items-center justify-content-between">
+                            <div class="fw-semibold">New ticket</div>
+                            <button type="button" class="btn btn-sm btn-outline-primary" id="rcm_ticket_save">Add</button>
+                          </div>
+                          <div class="mt-2">
+                            <input class="form-control form-control-sm" id="rcm_ticket_code" type="text" placeholder="Ticket number (e.g., T20260106.0001)" />
+                            </div>
+<div class="mt-2 small text-muted" id="rcm_ticket_status"></div>
+                        </div>
+                      </div>
                       <div class="col-12 col-lg-6">
                         <div class="border rounded p-2">
                           <div class="d-flex align-items-center justify-content-between">
@@ -297,48 +299,10 @@
     var currentRunId = null;
     var currentPayload = null;
 
-    // Phase 2.1: Read-only Autotask ticket polling (Run Checks page only)
-    // Cache shape: { <ticketId>: {id, ticketNumber, status, statusName, title, lastActivityDate} }
-    var autotaskTicketPollCache = {};
-
-    function pollAutotaskTicketsOnPageOpen() {
-      // Only execute on Run Checks page load.
-      var url = '/api/run-checks/autotask-ticket-poll';
-      var qs = [];
-      // include_reviewed is only meaningful for admins
-      try {
-        var includeReviewed = {{ 'true' if include_reviewed else 'false' }};
-        if (includeReviewed) qs.push('include_reviewed=1');
-      } catch (e) {}
-      if (qs.length) url += '?' + qs.join('&');
-
-      fetch(url)
-        .then(function (r) { return r.json(); })
-        .then(function (j) {
-          if (!j || j.status !== 'ok') return;
-          autotaskTicketPollCache = {};
-          var list = (j.tickets || []);
-          for (var i = 0; i < list.length; i++) {
-            var t = list[i] || {};
-            var id = parseInt(t.id, 10);
-            if (!Number.isFinite(id) || id <= 0) continue;
-            autotaskTicketPollCache[id] = t;
-          }
-          window.__rcAutotaskTicketPollCache = autotaskTicketPollCache;
-        })
-        .catch(function () {
-          autotaskTicketPollCache = {};
-          window.__rcAutotaskTicketPollCache = autotaskTicketPollCache;
-        });
-    }
-
-
     var btnMarkAllReviewed = document.getElementById('rcm_mark_all_reviewed');
     var btnMarkSuccessOverride = document.getElementById('rcm_mark_success_override');
 
-        pollAutotaskTicketsOnPageOpen();
-
-// Shift-click range selection for checkbox rows
+    // Shift-click range selection for checkbox rows
     var lastCheckedCb = null;
 
     
@@ -877,99 +841,56 @@ table.addEventListener('change', function (e) {
     }
 
     function bindInlineCreateForms() {
-      var btnAutotask = document.getElementById('rcm_autotask_create');
-      var atInfo = document.getElementById('rcm_autotask_info');
-      var atStatus = document.getElementById('rcm_autotask_status');
-
+      var btnTicket = document.getElementById('rcm_ticket_save');
       var btnRemark = document.getElementById('rcm_remark_save');
+      var tCode = document.getElementById('rcm_ticket_code');
+var tStatus = document.getElementById('rcm_ticket_status');
       var rBody = document.getElementById('rcm_remark_body');
       var rStatus = document.getElementById('rcm_remark_status');
 
       function clearStatus() {
-        if (atStatus) atStatus.textContent = '';
+        if (tStatus) tStatus.textContent = '';
         if (rStatus) rStatus.textContent = '';
       }
 
       function setDisabled(disabled) {
-        if (btnAutotask) btnAutotask.disabled = disabled;
+        if (btnTicket) btnTicket.disabled = disabled;
         if (btnRemark) btnRemark.disabled = disabled;
-        if (rBody) rBody.disabled = disabled;
+        if (tCode) tCode.disabled = disabled;
+if (rBody) rBody.disabled = disabled;
       }
 
       window.__rcmSetCreateDisabled = setDisabled;
       window.__rcmClearCreateStatus = clearStatus;
 
-      function renderAutotaskInfo(run) {
-        if (!atInfo) return;
-        var num = (run && run.autotask_ticket_number) ? String(run.autotask_ticket_number) : '';
-        var tid = (run && run.autotask_ticket_id) ? parseInt(run.autotask_ticket_id, 10) : null;
-        var polled = (tid && autotaskTicketPollCache && autotaskTicketPollCache[tid]) ? autotaskTicketPollCache[tid] : null;
-
-        var lines = [];
-        if (num) {
-          lines.push('<div><strong>Ticket:</strong> ' + escapeHtml(num) + '</div>');
-        } else if (tid) {
-          lines.push('<div><strong>Ticket:</strong> created</div>');
-        } else {
-          lines.push('<div class="text-muted">No Autotask ticket created for this run.</div>');
-        }
-
-        // Phase 2.1 visibility only: show last polled status if available
-        if (tid) {
-          if (polled) {
-            var statusName = (polled.statusName || '').toString().trim();
-            var statusVal = (polled.status !== undefined && polled.status !== null) ? String(polled.status) : '';
-            var label = statusName ? statusName : (statusVal ? ('Status ' + statusVal) : '');
-            if (label) {
-              lines.push('<div class="text-muted">PSA status (polled): ' + escapeHtml(label) + '</div>');
-            }
-          } else {
-            lines.push('<div class="text-muted">PSA status (polled): not available</div>');
-          }
-        }
-
-        atInfo.innerHTML = lines.join('');
-}
-      window.__rcmRenderAutotaskInfo = renderAutotaskInfo;
-
-      if (btnAutotask) {
-        btnAutotask.addEventListener('click', function () {
+      if (btnTicket) {
+        btnTicket.addEventListener('click', function () {
           if (!currentRunId) { alert('Select a run first.'); return; }
           clearStatus();
-          if (atStatus) atStatus.textContent = 'Creating ticket...';
-          btnAutotask.disabled = true;
-          apiJson('/api/run-checks/autotask-ticket', {
+          var ticket_code = tCode ? (tCode.value || '').trim().toUpperCase() : '';
+if (!ticket_code) {
+            if (tStatus) tStatus.textContent = 'Ticket number is required.';
+            else alert('Ticket number is required.');
+            return;
+          }
+          if (!/^T\d{8}\.\d{4}$/.test(ticket_code)) {
+            if (tStatus) tStatus.textContent = 'Invalid ticket number format. Expected TYYYYMMDD.####.';
+            else alert('Invalid ticket number format. Expected TYYYYMMDD.####.');
+            return;
+          }
+          if (tStatus) tStatus.textContent = 'Saving...';
+          apiJson('/api/tickets', {
             method: 'POST',
-            body: JSON.stringify({run_id: currentRunId})
+            body: JSON.stringify({job_run_id: currentRunId, ticket_code: ticket_code})
           })
-          .then(function (j) {
-            if (!j || j.status !== 'ok') throw new Error((j && j.message) || 'Failed.');
-            if (atStatus) atStatus.textContent = '';
-
-            // Refresh modal data so UI reflects stored ticket linkage.
-            var keepRunId = currentRunId;
-            if (currentJobId) {
-              return fetch('/api/run-checks/details?job_id=' + encodeURIComponent(currentJobId))
-                .then(function (r) { return r.json(); })
-                .then(function (payload) {
-                  currentPayload = payload;
-                  // Find the same run index
-                  var idx = 0;
-                  var runs = (payload && payload.runs) || [];
-                  for (var i = 0; i < runs.length; i++) {
-                    if (String(runs[i].id) === String(keepRunId)) { idx = i; break; }
-                  }
-                  // Re-render the currently open Run Checks modal with fresh data.
-                  renderRun(payload, idx);
-                });
-            }
+          .then(function () {
+            if (tCode) tCode.value = '';
+if (tStatus) tStatus.textContent = '';
+            loadAlerts(currentRunId);
           })
           .catch(function (e) {
-            if (atStatus) atStatus.textContent = e.message || 'Failed.';
+            if (tStatus) tStatus.textContent = e.message || 'Failed.';
             else alert(e.message || 'Failed.');
-          })
-          .finally(function () {
-            // State will be recalculated by renderRun.
           });
         });
       }
@@ -1035,8 +956,7 @@ table.addEventListener('change', function (e) {
 
       currentRunId = run.id || null;
       if (window.__rcmClearCreateStatus) window.__rcmClearCreateStatus();
-      if (window.__rcmRenderAutotaskInfo) window.__rcmRenderAutotaskInfo(run);
-      if (window.__rcmSetCreateDisabled) window.__rcmSetCreateDisabled(!currentRunId || !!run.autotask_ticket_id);
+      if (window.__rcmSetCreateDisabled) window.__rcmSetCreateDisabled(!currentRunId);
       if (btnMarkSuccessOverride) {
         var _rs = (run.status || '').toString().toLowerCase();
         var _canOverride = !!currentRunId && !run.missed && (_rs.indexOf('override') === -1) && (_rs.indexOf('success') === -1);
@@ -1224,10 +1144,9 @@ table.addEventListener('change', function (e) {
             var dot = run.missed ? "dot-missed" : statusDotClass(run.status);
             var dotHtml = dot ? ('<span class="status-dot ' + dot + ' me-2" aria-hidden="true"></span>') : '';
             var reviewedMark = run.is_reviewed ? ' <span class="ms-2" title="Reviewed" aria-label="Reviewed">✔</span>' : '';
-            var ticketMark = run.autotask_ticket_id ? ' <span class="ms-2" title="Autotask ticket created" aria-label="Autotask ticket">🎫</span>' : '';
 
             a.title = run.status || '';
-            a.innerHTML = dotHtml + '<span class="text-nowrap">' + escapeHtml(run.run_at || 'Run') + '</span>' + reviewedMark + ticketMark;
+            a.innerHTML = dotHtml + '<span class="text-nowrap">' + escapeHtml(run.run_at || 'Run') + '</span>' + reviewedMark;
             a.addEventListener('click', function (ev) {
               ev.preventDefault();
               renderRun(data, idx);
diff --git a/containers/backupchecks/src/templates/main/settings.html b/containers/backupchecks/src/templates/main/settings.html
index 3b848e0..6c52acb 100644
--- a/containers/backupchecks/src/templates/main/settings.html
+++ b/containers/backupchecks/src/templates/main/settings.html
@@ -397,17 +397,6 @@
           <div class="form-text">Requires refreshed reference data.</div>
         </div>
 
-        <div class="col-md-6">
-          <label for="autotask_default_ticket_status" class="form-label">Default Ticket Status</label>
-          <select class="form-select" id="autotask_default_ticket_status" name="autotask_default_ticket_status">
-            <option value="" {% if not settings.autotask_default_ticket_status %}selected{% endif %}>Select...</option>
-            {% for st in autotask_ticket_statuses %}
-              <option value="{{ st.id }}" {% if settings.autotask_default_ticket_status == st.id %}selected{% endif %}>{{ st.name }}</option>
-            {% endfor %}
-          </select>
-          <div class="form-text">Required for Autotask ticket creation. Requires refreshed reference data.</div>
-        </div>
-
         <div class="col-md-6">
           <label for="autotask_priority_warning" class="form-label">Priority for Warning</label>
           <select class="form-select" id="autotask_priority_warning" name="autotask_priority_warning">
@@ -455,7 +444,6 @@
         <div class="text-muted small mt-2">
           Cached Queues: {{ autotask_queues|length }}<br />
           Cached Ticket Sources: {{ autotask_ticket_sources|length }}<br />
-          Cached Ticket Statuses: {{ autotask_ticket_statuses|length }}<br />
           Cached Priorities: {{ autotask_priorities|length }}
         </div>
       </div>
@@ -468,7 +456,7 @@
             <button type="submit" class="btn btn-outline-primary">Refresh reference data</button>
           </form>
         </div>
-        <div class="form-text mt-2 text-md-end">Refresh loads Queues, Ticket Sources, Ticket Statuses, and Priorities from Autotask for dropdown usage.</div>
+        <div class="form-text mt-2 text-md-end">Refresh loads Queues, Ticket Sources, and Priorities from Autotask for dropdown usage.</div>
       </div>
     </div>
   </div>

From 36deb77806a844a75a9aa3836bb653578ced93ec Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Mon, 19 Jan 2026 11:20:52 +0100
Subject: [PATCH 35/63] Auto-commit local changes before build (2026-01-19
 11:20:52)

---
 .last-branch                                  |   2 +-
 .../app/integrations/autotask/client.py       |  43 ++-
 .../src/backend/app/main/routes_run_checks.py | 274 +++++++++++++++++-
 .../src/backend/app/main/routes_settings.py   |  14 +-
 .../src/backend/app/migrations.py             |  63 ++++
 .../backupchecks/src/backend/app/models.py    |   9 +
 .../src/templates/main/run_checks.html        | 106 ++++---
 .../src/templates/main/settings.html          |  14 +-
 8 files changed, 477 insertions(+), 48 deletions(-)

diff --git a/.last-branch b/.last-branch
index 54b4e7f..371b3cc 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260119-01-restoredto-v20260115-12-autotask-customers-refreshall-mappings
+v20260119-02-restoredto--v20260115-15-autotask-default-ticket-status-setting
diff --git a/containers/backupchecks/src/backend/app/integrations/autotask/client.py b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
index 6aa9981..59a62f0 100644
--- a/containers/backupchecks/src/backend/app/integrations/autotask/client.py
+++ b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
@@ -105,7 +105,13 @@ class AutotaskClient:
             "Accept": "application/json",
         }
 
-    def _request(self, method: str, path: str, params: Optional[Dict[str, Any]] = None) -> Any:
+    def _request(
+        self,
+        method: str,
+        path: str,
+        params: Optional[Dict[str, Any]] = None,
+        json_body: Optional[Dict[str, Any]] = None,
+    ) -> Any:
         zone = self.get_zone_info()
         base = zone.api_url.rstrip("/")
         url = f"{base}/v1.0/{path.lstrip('/')}"
@@ -120,6 +126,7 @@ class AutotaskClient:
                 url=url,
                 headers=h,
                 params=params or None,
+                json=json_body if json_body is not None else None,
                 auth=(self.username, self.password) if use_basic_auth else None,
                 timeout=self.timeout_seconds,
             )
@@ -389,3 +396,37 @@ class AutotaskClient:
             raise AutotaskError("Tickets.priority metadata did not include picklist values.")
 
         return self._call_picklist_values(picklist_values)
+
+    def get_ticket_statuses(self) -> List[Dict[str, Any]]:
+        """Return Ticket Status picklist values.
+
+        We retrieve this from Tickets field metadata to avoid hardcoded status IDs.
+        """
+        return self._get_ticket_picklist_values(field_names=["status", "statusid"])
+
+    def create_ticket(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """Create a Ticket in Autotask.
+
+        Uses POST /Tickets.
+        Returns the created ticket object (as returned by Autotask).
+        """
+        if not isinstance(payload, dict) or not payload:
+            raise AutotaskError("Ticket payload is empty.")
+
+        data = self._request("POST", "Tickets", json_body=payload)
+        # Autotask commonly returns the created object or an items list.
+        if isinstance(data, dict):
+            if "item" in data and isinstance(data.get("item"), dict):
+                return data["item"]
+            if "items" in data and isinstance(data.get("items"), list) and data.get("items"):
+                first = data.get("items")[0]
+                if isinstance(first, dict):
+                    return first
+            if "id" in data:
+                return data
+        # Fallback: return normalized first item if possible
+        items = self._as_items_list(data)
+        if items:
+            return items[0]
+
+        raise AutotaskError("Autotask did not return a created ticket object.")
diff --git a/containers/backupchecks/src/backend/app/main/routes_run_checks.py b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
index b073af2..b66350c 100644
--- a/containers/backupchecks/src/backend/app/main/routes_run_checks.py
+++ b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
@@ -4,7 +4,8 @@ import calendar
 
 from datetime import date, datetime, time, timedelta, timezone
 
-from flask import jsonify, render_template, request
+from flask import jsonify, render_template, request, url_for
+from urllib.parse import urljoin
 from flask_login import current_user, login_required
 from sqlalchemy import and_, or_, func, text
 
@@ -35,6 +36,106 @@ from ..models import (
     User,
 )
 
+
+def _build_autotask_client_from_settings():
+    """Build an AutotaskClient from stored settings or raise a user-safe exception."""
+    settings = _get_or_create_settings()
+    if not getattr(settings, "autotask_enabled", False):
+        raise RuntimeError("Autotask integration is disabled.")
+
+    required = [
+        getattr(settings, "autotask_environment", None),
+        getattr(settings, "autotask_api_username", None),
+        getattr(settings, "autotask_api_password", None),
+        getattr(settings, "autotask_tracking_identifier", None),
+    ]
+    if any(not (x and str(x).strip()) for x in required):
+        raise RuntimeError("Autotask settings incomplete.")
+
+    from ..integrations.autotask.client import AutotaskClient
+
+    return AutotaskClient(
+        username=settings.autotask_api_username,
+        password=settings.autotask_api_password,
+        api_integration_code=settings.autotask_tracking_identifier,
+        environment=settings.autotask_environment,
+    )
+
+
+def _determine_autotask_severity(status_text: str | None) -> str:
+    s = (status_text or "").strip().lower()
+    if "warning" in s:
+        return "warning"
+    if "error" in s or "fail" in s:
+        return "error"
+    if "missed" in s:
+        return "error"
+    return "warning"
+
+
+def _compose_autotask_ticket_description(
+    *,
+    settings,
+    job: Job,
+    run: JobRun,
+    status_display: str,
+    overall_message: str,
+    objects_payload: list[dict[str, str]],
+) -> str:
+    tz_name = _get_ui_timezone_name() or "Europe/Amsterdam"
+    run_dt = run.run_at
+    run_at_str = _format_datetime(run_dt) if run_dt else "-"
+
+    base_url = (getattr(settings, "autotask_base_url", None) or "").strip()
+    job_rel = url_for("main.job_detail", job_id=job.id)
+    # Link to Job Details with a hint for the specific run.
+    job_link = urljoin(base_url.rstrip("/") + "/", job_rel.lstrip("/"))
+    if run.id:
+        job_link = f"{job_link}?run_id={int(run.id)}"
+
+    lines: list[str] = []
+    lines.append(f"Customer: {job.customer.name if job.customer else ''}")
+    lines.append(f"Job: {job.job_name or ''}")
+    lines.append(f"Backup: {job.backup_software or ''} / {job.backup_type or ''}")
+    lines.append(f"Run at ({tz_name}): {run_at_str}")
+    lines.append(f"Status: {status_display or ''}")
+    lines.append("")
+
+    overall_message = (overall_message or "").strip()
+    if overall_message:
+        lines.append("Summary:")
+        lines.append(overall_message)
+        lines.append("")
+        lines.append("Multiple objects reported messages. See Backupchecks for full details.")
+    else:
+        # Fallback to object-level messages with a hard limit.
+        limit = 10
+        shown = 0
+        total = 0
+        for o in objects_payload or []:
+            name = (o.get("name") or "").strip()
+            err = (o.get("error_message") or "").strip()
+            st = (o.get("status") or "").strip()
+            if not name:
+                continue
+            if not err and not st:
+                continue
+            total += 1
+            if shown >= limit:
+                continue
+            msg = err or st
+            lines.append(f"- {name}: {msg}")
+            shown += 1
+
+        if total == 0:
+            lines.append("No detailed object messages available. See Backupchecks for full details.")
+        elif total > shown:
+            lines.append(f"And {int(total - shown)} additional objects reported similar messages.")
+
+    lines.append("")
+    lines.append(f"Backupchecks details: {job_link}")
+    return "\n".join(lines).strip() + "\n"
+
 # Grace window for matching real runs to an expected schedule slot.
 # A run within +/- 1 hour of the inferred schedule time counts as fulfilling the slot.
 MISSED_GRACE_WINDOW = timedelta(hours=1)
@@ -753,6 +854,8 @@ def run_checks_details():
                 "mail": mail_meta,
                 "body_html": body_html,
                 "objects": objects_payload,
+                "autotask_ticket_id": getattr(run, "autotask_ticket_id", None),
+                "autotask_ticket_number": getattr(run, "autotask_ticket_number", None) or "",
             }
         )
 
@@ -770,6 +873,175 @@ def run_checks_details():
     return jsonify({"status": "ok", "job": job_payload, "runs": runs_payload})
 
 
+@main_bp.post("/api/run-checks/autotask-ticket")
+@login_required
+@roles_required("admin", "operator")
+def api_run_checks_create_autotask_ticket():
+    """Create an Autotask ticket for a specific run.
+
+    Enforces: exactly one ticket per run.
+    """
+    data = request.get_json(silent=True) or {}
+    try:
+        run_id = int(data.get("run_id") or 0)
+    except Exception:
+        run_id = 0
+
+    if run_id <= 0:
+        return jsonify({"status": "error", "message": "Invalid parameters."}), 400
+
+    run = JobRun.query.get(run_id)
+    if not run:
+        return jsonify({"status": "error", "message": "Run not found."}), 404
+
+    # Idempotent: if already created, return existing linkage.
+    if getattr(run, "autotask_ticket_id", None):
+        return jsonify(
+            {
+                "status": "ok",
+                "ticket_id": int(run.autotask_ticket_id),
+                "ticket_number": getattr(run, "autotask_ticket_number", None) or "",
+                "already_exists": True,
+            }
+        )
+
+    job = Job.query.get(run.job_id)
+    if not job:
+        return jsonify({"status": "error", "message": "Job not found."}), 404
+
+    customer = Customer.query.get(job.customer_id) if getattr(job, "customer_id", None) else None
+    if not customer:
+        return jsonify({"status": "error", "message": "Customer not found."}), 404
+
+    if not getattr(customer, "autotask_company_id", None):
+        return jsonify({"status": "error", "message": "Customer has no Autotask company mapping."}), 400
+
+    if (getattr(customer, "autotask_mapping_status", None) or "").strip().lower() not in ("ok", "renamed"):
+        return jsonify({"status": "error", "message": "Autotask company mapping is not valid."}), 400
+
+    settings = _get_or_create_settings()
+
+    base_url = (getattr(settings, "autotask_base_url", None) or "").strip()
+    if not base_url:
+        return jsonify({"status": "error", "message": "Autotask Base URL is not configured."}), 400
+
+    # Required ticket defaults
+    if not getattr(settings, "autotask_default_queue_id", None):
+        return jsonify({"status": "error", "message": "Autotask default queue is not configured."}), 400
+    if not getattr(settings, "autotask_default_ticket_source_id", None):
+        return jsonify({"status": "error", "message": "Autotask default ticket source is not configured."}), 400
+    if not getattr(settings, "autotask_default_ticket_status", None):
+        return jsonify({"status": "error", "message": "Autotask default ticket status is not configured."}), 400
+
+    # Determine display status (including overrides) for consistent subject/priority mapping.
+    status_display = run.status or "-"
+    try:
+        status_display, _, _, _ov_id, _ov_reason = _apply_overrides_to_run(job, run)
+    except Exception:
+        status_display = run.status or "-"
+
+    severity = _determine_autotask_severity(status_display)
+    priority_id = None
+    if severity == "warning":
+        priority_id = getattr(settings, "autotask_priority_warning", None)
+    else:
+        priority_id = getattr(settings, "autotask_priority_error", None)
+
+    # Load mail + objects for ticket composition.
+    msg = MailMessage.query.get(run.mail_message_id) if run.mail_message_id else None
+    overall_message = (getattr(msg, "overall_message", None) or "") if msg else ""
+
+    objects_payload: list[dict[str, str]] = []
+    try:
+        objs = run.objects.order_by(JobObject.object_name.asc()).all()
+    except Exception:
+        objs = list(run.objects or [])
+    for o in objs or []:
+        objects_payload.append(
+            {
+                "name": getattr(o, "object_name", "") or "",
+                "type": getattr(o, "object_type", "") or "",
+                "status": getattr(o, "status", "") or "",
+                "error_message": getattr(o, "error_message", "") or "",
+            }
+        )
+
+    if (not objects_payload) and msg:
+        try:
+            mos = MailObject.query.filter_by(mail_message_id=msg.id).order_by(MailObject.object_name.asc()).all()
+        except Exception:
+            mos = []
+        for mo in mos or []:
+            objects_payload.append(
+                {
+                    "name": getattr(mo, "object_name", "") or "",
+                    "type": getattr(mo, "object_type", "") or "",
+                    "status": getattr(mo, "status", "") or "",
+                    "error_message": getattr(mo, "error_message", "") or "",
+                }
+            )
+
+    subject = f"[Backupchecks] {customer.name} - {job.job_name or ''} - {status_display}"
+    description = _compose_autotask_ticket_description(
+        settings=settings,
+        job=job,
+        run=run,
+        status_display=status_display,
+        overall_message=overall_message,
+        objects_payload=objects_payload,
+    )
+
+    payload = {
+        "companyID": int(customer.autotask_company_id),
+        "title": subject,
+        "description": description,
+        "queueID": int(settings.autotask_default_queue_id),
+        "source": int(settings.autotask_default_ticket_source_id),
+        "status": int(settings.autotask_default_ticket_status),
+    }
+    if priority_id:
+        payload["priority"] = int(priority_id)
+
+    try:
+        client = _build_autotask_client_from_settings()
+        created = client.create_ticket(payload)
+    except Exception as exc:
+        return jsonify({"status": "error", "message": f"Autotask ticket creation failed: {exc}"}), 400
+
+    ticket_id = created.get("id") if isinstance(created, dict) else None
+    ticket_number = None
+    if isinstance(created, dict):
+        ticket_number = created.get("ticketNumber") or created.get("number") or created.get("ticket_number")
+
+    if not ticket_id:
+        return jsonify({"status": "error", "message": "Autotask did not return a ticket id."}), 400
+
+    try:
+        run.autotask_ticket_id = int(ticket_id)
+    except Exception:
+        run.autotask_ticket_id = None
+
+    run.autotask_ticket_number = (str(ticket_number).strip() if ticket_number is not None else "") or None
+    run.autotask_ticket_created_at = datetime.utcnow()
+    run.autotask_ticket_created_by_user_id = current_user.id
+
+    try:
+        db.session.add(run)
+        db.session.commit()
+    except Exception as exc:
+        db.session.rollback()
+        return jsonify({"status": "error", "message": f"Failed to store ticket reference: {exc}"}), 500
+
+    return jsonify(
+        {
+            "status": "ok",
+            "ticket_id": int(run.autotask_ticket_id) if run.autotask_ticket_id else None,
+            "ticket_number": run.autotask_ticket_number or "",
+            "already_exists": False,
+        }
+    )
+
+
 @main_bp.post("/api/run-checks/mark-reviewed")
 @login_required
 @roles_required("admin", "operator")
diff --git a/containers/backupchecks/src/backend/app/main/routes_settings.py b/containers/backupchecks/src/backend/app/main/routes_settings.py
index 5897121..2160fb5 100644
--- a/containers/backupchecks/src/backend/app/main/routes_settings.py
+++ b/containers/backupchecks/src/backend/app/main/routes_settings.py
@@ -657,6 +657,7 @@ def settings():
     autotask_queues = []
     autotask_ticket_sources = []
     autotask_priorities = []
+    autotask_ticket_statuses = []
     autotask_last_sync_at = getattr(settings, "autotask_reference_last_sync_at", None)
 
     try:
@@ -677,6 +678,12 @@ def settings():
     except Exception:
         autotask_priorities = []
 
+    try:
+        if getattr(settings, "autotask_cached_ticket_statuses_json", None):
+            autotask_ticket_statuses = json.loads(settings.autotask_cached_ticket_statuses_json) or []
+    except Exception:
+        autotask_ticket_statuses = []
+
     return render_template(
         "main/settings.html",
         settings=settings,
@@ -692,6 +699,7 @@ def settings():
         autotask_queues=autotask_queues,
         autotask_ticket_sources=autotask_ticket_sources,
         autotask_priorities=autotask_priorities,
+        autotask_ticket_statuses=autotask_ticket_statuses,
         autotask_last_sync_at=autotask_last_sync_at,
         news_admin_items=news_admin_items,
         news_admin_stats=news_admin_stats,
@@ -1322,6 +1330,7 @@ def settings_autotask_refresh_reference_data():
         queues = client.get_queues()
         sources = client.get_ticket_sources()
         priorities = client.get_ticket_priorities()
+        statuses = client.get_ticket_statuses()
 
         # Store a minimal subset for dropdowns (id + name/label)
         # Note: Some "reference" values are exposed as picklists (value/label)
@@ -1354,6 +1363,7 @@ def settings_autotask_refresh_reference_data():
 
         settings.autotask_cached_queues_json = json.dumps(_norm(queues))
         settings.autotask_cached_ticket_sources_json = json.dumps(_norm(sources))
+        settings.autotask_cached_ticket_statuses_json = json.dumps(_norm(statuses))
 
         # Priorities are returned as picklist values (value/label)
         pr_out = []
@@ -1377,13 +1387,13 @@ def settings_autotask_refresh_reference_data():
         db.session.commit()
 
         flash(
-            f"Autotask reference data refreshed. Queues: {len(queues)}. Ticket Sources: {len(sources)}. Priorities: {len(pr_out)}.",
+            f"Autotask reference data refreshed. Queues: {len(queues)}. Ticket Sources: {len(sources)}. Ticket Statuses: {len(statuses)}. Priorities: {len(pr_out)}.",
             "success",
         )
         _log_admin_event(
             "autotask_refresh_reference_data",
             "Autotask reference data refreshed.",
-            details=json.dumps({"queues": len(queues or []), "ticket_sources": len(sources or []), "priorities": len(pr_out)}),
+            details=json.dumps({"queues": len(queues or []), "ticket_sources": len(sources or []), "ticket_statuses": len(statuses or []), "priorities": len(pr_out)}),
         )
     except Exception as exc:
         flash(f"Failed to refresh Autotask reference data: {exc}", "danger")
diff --git a/containers/backupchecks/src/backend/app/migrations.py b/containers/backupchecks/src/backend/app/migrations.py
index 6c21f5e..b1d1405 100644
--- a/containers/backupchecks/src/backend/app/migrations.py
+++ b/containers/backupchecks/src/backend/app/migrations.py
@@ -168,6 +168,7 @@ def migrate_system_settings_autotask_integration() -> None:
         ("autotask_cached_queues_json", "TEXT NULL"),
         ("autotask_cached_ticket_sources_json", "TEXT NULL"),
         ("autotask_cached_priorities_json", "TEXT NULL"),
+        ("autotask_cached_ticket_statuses_json", "TEXT NULL"),
         ("autotask_reference_last_sync_at", "TIMESTAMP NULL"),
     ]
 
@@ -897,6 +898,7 @@ def run_migrations() -> None:
     migrate_overrides_match_columns()
     migrate_job_runs_review_tracking()
     migrate_job_runs_override_metadata()
+    migrate_job_runs_autotask_ticket_fields()
     migrate_jobs_archiving()
     migrate_news_tables()
     migrate_reporting_tables()
@@ -904,6 +906,67 @@ def run_migrations() -> None:
     print("[migrations] All migrations completed.")
 
 
+def migrate_job_runs_autotask_ticket_fields() -> None:
+    """Add Autotask ticket linkage fields to job_runs if missing.
+
+    Columns:
+    - job_runs.autotask_ticket_id (INTEGER NULL)
+    - job_runs.autotask_ticket_number (VARCHAR(64) NULL)
+    - job_runs.autotask_ticket_created_at (TIMESTAMP NULL)
+    - job_runs.autotask_ticket_created_by_user_id (INTEGER NULL, FK users.id)
+    """
+
+    table = "job_runs"
+    try:
+        engine = db.get_engine()
+    except Exception as exc:
+        print(f"[migrations] Could not get engine for job_runs Autotask ticket migration: {exc}")
+        return
+
+    try:
+        with engine.connect() as conn:
+            cols = _get_table_columns(conn, table)
+            if not cols:
+                return
+
+            if "autotask_ticket_id" not in cols:
+                print("[migrations] Adding job_runs.autotask_ticket_id column...")
+                conn.execute(text('ALTER TABLE "job_runs" ADD COLUMN autotask_ticket_id INTEGER'))
+
+            if "autotask_ticket_number" not in cols:
+                print("[migrations] Adding job_runs.autotask_ticket_number column...")
+                conn.execute(text('ALTER TABLE "job_runs" ADD COLUMN autotask_ticket_number VARCHAR(64)'))
+
+            if "autotask_ticket_created_at" not in cols:
+                print("[migrations] Adding job_runs.autotask_ticket_created_at column...")
+                conn.execute(text('ALTER TABLE "job_runs" ADD COLUMN autotask_ticket_created_at TIMESTAMP'))
+
+            if "autotask_ticket_created_by_user_id" not in cols:
+                print("[migrations] Adding job_runs.autotask_ticket_created_by_user_id column...")
+                conn.execute(text('ALTER TABLE "job_runs" ADD COLUMN autotask_ticket_created_by_user_id INTEGER'))
+
+                try:
+                    conn.execute(
+                        text(
+                            'ALTER TABLE "job_runs" '
+                            'ADD CONSTRAINT job_runs_autotask_ticket_created_by_user_id_fkey '
+                            'FOREIGN KEY (autotask_ticket_created_by_user_id) REFERENCES users(id) '
+                            'ON DELETE SET NULL'
+                        )
+                    )
+                except Exception as exc:
+                    print(
+                        f"[migrations] Could not add FK job_runs.autotask_ticket_created_by_user_id -> users.id (continuing): {exc}"
+                    )
+
+            conn.execute(text('CREATE INDEX IF NOT EXISTS idx_job_runs_autotask_ticket_id ON "job_runs" (autotask_ticket_id)'))
+    except Exception as exc:
+        print(f"[migrations] job_runs table not found; skipping migrate_job_runs_autotask_ticket_fields: {exc}")
+        return
+
+    print("[migrations] migrate_job_runs_autotask_ticket_fields completed.")
+
+
 def migrate_jobs_archiving() -> None:
     """Add archiving columns to jobs if missing.
 
diff --git a/containers/backupchecks/src/backend/app/models.py b/containers/backupchecks/src/backend/app/models.py
index e72a846..4ecba7d 100644
--- a/containers/backupchecks/src/backend/app/models.py
+++ b/containers/backupchecks/src/backend/app/models.py
@@ -127,6 +127,7 @@ class SystemSettings(db.Model):
     autotask_cached_queues_json = db.Column(db.Text, nullable=True)
     autotask_cached_ticket_sources_json = db.Column(db.Text, nullable=True)
     autotask_cached_priorities_json = db.Column(db.Text, nullable=True)
+    autotask_cached_ticket_statuses_json = db.Column(db.Text, nullable=True)
     autotask_reference_last_sync_at = db.Column(db.DateTime, nullable=True)
     created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
     updated_at = db.Column(
@@ -275,6 +276,12 @@ class JobRun(db.Model):
     reviewed_at = db.Column(db.DateTime, nullable=True)
     reviewed_by_user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=True)
 
+    # Autotask integration (Phase 4: ticket creation from Run Checks)
+    autotask_ticket_id = db.Column(db.Integer, nullable=True)
+    autotask_ticket_number = db.Column(db.String(64), nullable=True)
+    autotask_ticket_created_at = db.Column(db.DateTime, nullable=True)
+    autotask_ticket_created_by_user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=True)
+
 
     created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
     updated_at = db.Column(
@@ -288,6 +295,8 @@ class JobRun(db.Model):
 
     reviewed_by = db.relationship("User", foreign_keys=[reviewed_by_user_id])
 
+    autotask_ticket_created_by = db.relationship("User", foreign_keys=[autotask_ticket_created_by_user_id])
+
 
 class JobRunReviewEvent(db.Model):
     __tablename__ = "job_run_review_events"
diff --git a/containers/backupchecks/src/templates/main/run_checks.html b/containers/backupchecks/src/templates/main/run_checks.html
index 90de7aa..4701bb2 100644
--- a/containers/backupchecks/src/templates/main/run_checks.html
+++ b/containers/backupchecks/src/templates/main/run_checks.html
@@ -214,18 +214,16 @@
                   <div id="rcm_alerts" class="small"></div>
                   <div class="mt-2">
                     <div class="row g-2 align-items-start">
-                      <div class="col-12 col-lg-6">
-                        <div class="border rounded p-2">
-                          <div class="d-flex align-items-center justify-content-between">
-                            <div class="fw-semibold">New ticket</div>
-                            <button type="button" class="btn btn-sm btn-outline-primary" id="rcm_ticket_save">Add</button>
-                          </div>
-                          <div class="mt-2">
-                            <input class="form-control form-control-sm" id="rcm_ticket_code" type="text" placeholder="Ticket number (e.g., T20260106.0001)" />
-                            </div>
-<div class="mt-2 small text-muted" id="rcm_ticket_status"></div>
-                        </div>
-                      </div>
+	                      <div class="col-12 col-lg-6">
+	                        <div class="border rounded p-2">
+	                          <div class="d-flex align-items-center justify-content-between">
+	                            <div class="fw-semibold">Autotask ticket</div>
+	                            <button type="button" class="btn btn-sm btn-outline-primary" id="rcm_autotask_create">Create</button>
+	                          </div>
+	                          <div class="mt-2 small" id="rcm_autotask_info"></div>
+	                          <div class="mt-2 small text-muted" id="rcm_autotask_status"></div>
+	                        </div>
+	                      </div>
                       <div class="col-12 col-lg-6">
                         <div class="border rounded p-2">
                           <div class="d-flex align-items-center justify-content-between">
@@ -841,56 +839,78 @@ table.addEventListener('change', function (e) {
     }
 
     function bindInlineCreateForms() {
-      var btnTicket = document.getElementById('rcm_ticket_save');
+      var btnAutotask = document.getElementById('rcm_autotask_create');
+      var atInfo = document.getElementById('rcm_autotask_info');
+      var atStatus = document.getElementById('rcm_autotask_status');
+
       var btnRemark = document.getElementById('rcm_remark_save');
-      var tCode = document.getElementById('rcm_ticket_code');
-var tStatus = document.getElementById('rcm_ticket_status');
       var rBody = document.getElementById('rcm_remark_body');
       var rStatus = document.getElementById('rcm_remark_status');
 
       function clearStatus() {
-        if (tStatus) tStatus.textContent = '';
+        if (atStatus) atStatus.textContent = '';
         if (rStatus) rStatus.textContent = '';
       }
 
       function setDisabled(disabled) {
-        if (btnTicket) btnTicket.disabled = disabled;
+        if (btnAutotask) btnAutotask.disabled = disabled;
         if (btnRemark) btnRemark.disabled = disabled;
-        if (tCode) tCode.disabled = disabled;
-if (rBody) rBody.disabled = disabled;
+        if (rBody) rBody.disabled = disabled;
       }
 
       window.__rcmSetCreateDisabled = setDisabled;
       window.__rcmClearCreateStatus = clearStatus;
 
-      if (btnTicket) {
-        btnTicket.addEventListener('click', function () {
+      function renderAutotaskInfo(run) {
+        if (!atInfo) return;
+        var num = (run && run.autotask_ticket_number) ? String(run.autotask_ticket_number) : '';
+        if (num) {
+          atInfo.innerHTML = '<div><strong>Ticket:</strong> ' + escapeHtml(num) + '</div>';
+        } else if (run && run.autotask_ticket_id) {
+          atInfo.innerHTML = '<div><strong>Ticket:</strong> created</div>';
+        } else {
+          atInfo.innerHTML = '<div class="text-muted">No Autotask ticket created for this run.</div>';
+        }
+      }
+      window.__rcmRenderAutotaskInfo = renderAutotaskInfo;
+
+      if (btnAutotask) {
+        btnAutotask.addEventListener('click', function () {
           if (!currentRunId) { alert('Select a run first.'); return; }
           clearStatus();
-          var ticket_code = tCode ? (tCode.value || '').trim().toUpperCase() : '';
-if (!ticket_code) {
-            if (tStatus) tStatus.textContent = 'Ticket number is required.';
-            else alert('Ticket number is required.');
-            return;
-          }
-          if (!/^T\d{8}\.\d{4}$/.test(ticket_code)) {
-            if (tStatus) tStatus.textContent = 'Invalid ticket number format. Expected TYYYYMMDD.####.';
-            else alert('Invalid ticket number format. Expected TYYYYMMDD.####.');
-            return;
-          }
-          if (tStatus) tStatus.textContent = 'Saving...';
-          apiJson('/api/tickets', {
+          if (atStatus) atStatus.textContent = 'Creating ticket...';
+          btnAutotask.disabled = true;
+          apiJson('/api/run-checks/autotask-ticket', {
             method: 'POST',
-            body: JSON.stringify({job_run_id: currentRunId, ticket_code: ticket_code})
+            body: JSON.stringify({run_id: currentRunId})
           })
-          .then(function () {
-            if (tCode) tCode.value = '';
-if (tStatus) tStatus.textContent = '';
-            loadAlerts(currentRunId);
+          .then(function (j) {
+            if (!j || j.status !== 'ok') throw new Error((j && j.message) || 'Failed.');
+            if (atStatus) atStatus.textContent = '';
+
+            // Refresh modal data so UI reflects stored ticket linkage.
+            var keepRunId = currentRunId;
+            if (currentJobId) {
+              return fetch('/api/run-checks/details?job_id=' + encodeURIComponent(currentJobId))
+                .then(function (r) { return r.json(); })
+                .then(function (payload) {
+                  currentPayload = payload;
+                  // Find the same run index
+                  var idx = 0;
+                  var runs = (payload && payload.runs) || [];
+                  for (var i = 0; i < runs.length; i++) {
+                    if (String(runs[i].id) === String(keepRunId)) { idx = i; break; }
+                  }
+                  renderModal(payload, idx);
+                });
+            }
           })
           .catch(function (e) {
-            if (tStatus) tStatus.textContent = e.message || 'Failed.';
+            if (atStatus) atStatus.textContent = e.message || 'Failed.';
             else alert(e.message || 'Failed.');
+          })
+          .finally(function () {
+            // State will be recalculated by renderModal/renderRun.
           });
         });
       }
@@ -956,7 +976,8 @@ if (tStatus) tStatus.textContent = '';
 
       currentRunId = run.id || null;
       if (window.__rcmClearCreateStatus) window.__rcmClearCreateStatus();
-      if (window.__rcmSetCreateDisabled) window.__rcmSetCreateDisabled(!currentRunId);
+      if (window.__rcmRenderAutotaskInfo) window.__rcmRenderAutotaskInfo(run);
+      if (window.__rcmSetCreateDisabled) window.__rcmSetCreateDisabled(!currentRunId || !!run.autotask_ticket_id);
       if (btnMarkSuccessOverride) {
         var _rs = (run.status || '').toString().toLowerCase();
         var _canOverride = !!currentRunId && !run.missed && (_rs.indexOf('override') === -1) && (_rs.indexOf('success') === -1);
@@ -1144,9 +1165,10 @@ if (tStatus) tStatus.textContent = '';
             var dot = run.missed ? "dot-missed" : statusDotClass(run.status);
             var dotHtml = dot ? ('<span class="status-dot ' + dot + ' me-2" aria-hidden="true"></span>') : '';
             var reviewedMark = run.is_reviewed ? ' <span class="ms-2" title="Reviewed" aria-label="Reviewed">✔</span>' : '';
+            var ticketMark = run.autotask_ticket_id ? ' <span class="ms-2" title="Autotask ticket created" aria-label="Autotask ticket">🎫</span>' : '';
 
             a.title = run.status || '';
-            a.innerHTML = dotHtml + '<span class="text-nowrap">' + escapeHtml(run.run_at || 'Run') + '</span>' + reviewedMark;
+            a.innerHTML = dotHtml + '<span class="text-nowrap">' + escapeHtml(run.run_at || 'Run') + '</span>' + reviewedMark + ticketMark;
             a.addEventListener('click', function (ev) {
               ev.preventDefault();
               renderRun(data, idx);
diff --git a/containers/backupchecks/src/templates/main/settings.html b/containers/backupchecks/src/templates/main/settings.html
index 6c52acb..3b848e0 100644
--- a/containers/backupchecks/src/templates/main/settings.html
+++ b/containers/backupchecks/src/templates/main/settings.html
@@ -397,6 +397,17 @@
           <div class="form-text">Requires refreshed reference data.</div>
         </div>
 
+        <div class="col-md-6">
+          <label for="autotask_default_ticket_status" class="form-label">Default Ticket Status</label>
+          <select class="form-select" id="autotask_default_ticket_status" name="autotask_default_ticket_status">
+            <option value="" {% if not settings.autotask_default_ticket_status %}selected{% endif %}>Select...</option>
+            {% for st in autotask_ticket_statuses %}
+              <option value="{{ st.id }}" {% if settings.autotask_default_ticket_status == st.id %}selected{% endif %}>{{ st.name }}</option>
+            {% endfor %}
+          </select>
+          <div class="form-text">Required for Autotask ticket creation. Requires refreshed reference data.</div>
+        </div>
+
         <div class="col-md-6">
           <label for="autotask_priority_warning" class="form-label">Priority for Warning</label>
           <select class="form-select" id="autotask_priority_warning" name="autotask_priority_warning">
@@ -444,6 +455,7 @@
         <div class="text-muted small mt-2">
           Cached Queues: {{ autotask_queues|length }}<br />
           Cached Ticket Sources: {{ autotask_ticket_sources|length }}<br />
+          Cached Ticket Statuses: {{ autotask_ticket_statuses|length }}<br />
           Cached Priorities: {{ autotask_priorities|length }}
         </div>
       </div>
@@ -456,7 +468,7 @@
             <button type="submit" class="btn btn-outline-primary">Refresh reference data</button>
           </form>
         </div>
-        <div class="form-text mt-2 text-md-end">Refresh loads Queues, Ticket Sources, and Priorities from Autotask for dropdown usage.</div>
+        <div class="form-text mt-2 text-md-end">Refresh loads Queues, Ticket Sources, Ticket Statuses, and Priorities from Autotask for dropdown usage.</div>
       </div>
     </div>
   </div>

From dabec03f917bd68df202908d3a2ec9a2ec23adb9 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Mon, 19 Jan 2026 11:51:58 +0100
Subject: [PATCH 36/63] Auto-commit local changes before build (2026-01-19
 11:51:58)

---
 .last-branch                                  |   2 +-
 .../src/backend/app/main/routes_settings.py   | 181 +++++++++++-------
 2 files changed, 117 insertions(+), 66 deletions(-)

diff --git a/.last-branch b/.last-branch
index 371b3cc..a9c74c3 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260119-02-restoredto--v20260115-15-autotask-default-ticket-status-setting
+v20260119-03-autotask-reference-data-auto-refresh
diff --git a/containers/backupchecks/src/backend/app/main/routes_settings.py b/containers/backupchecks/src/backend/app/main/routes_settings.py
index 2160fb5..96dba4d 100644
--- a/containers/backupchecks/src/backend/app/main/routes_settings.py
+++ b/containers/backupchecks/src/backend/app/main/routes_settings.py
@@ -407,6 +407,8 @@ def settings():
     section = (request.args.get("section") or "general").strip().lower() or "general"
 
     if request.method == "POST":
+        autotask_form_touched = any(str(k).startswith("autotask_") for k in (request.form or {}).keys())
+
         # NOTE: The Settings UI has multiple tabs with separate forms.
         # Only update values that are present in the submitted form, to avoid
         # clearing unrelated settings when saving from another tab.
@@ -563,6 +565,48 @@ def settings():
             db.session.commit()
             flash("Settings have been saved.", "success")
 
+            # Autotask ticket defaults depend on reference data (queues, sources, statuses, priorities).
+            # When the Autotask integration is (re)configured, auto-refresh the cached reference data
+            # once so the dropdowns become usable immediately.
+            try:
+                if (
+                    autotask_form_touched
+                    and bool(getattr(settings, "autotask_enabled", False))
+                    and bool(getattr(settings, "autotask_api_username", None))
+                    and bool(getattr(settings, "autotask_api_password", None))
+                    and bool(getattr(settings, "autotask_tracking_identifier", None))
+                ):
+                    missing_cache = (
+                        not bool(getattr(settings, "autotask_cached_queues_json", None))
+                        or not bool(getattr(settings, "autotask_cached_ticket_sources_json", None))
+                        or not bool(getattr(settings, "autotask_cached_ticket_statuses_json", None))
+                        or not bool(getattr(settings, "autotask_cached_priorities_json", None))
+                    )
+
+                    if missing_cache:
+                        queues, sources, statuses, pr_out = _refresh_autotask_reference_data(settings)
+                        db.session.commit()
+                        flash(
+                            f"Autotask reference data refreshed. Queues: {len(queues)}. Ticket Sources: {len(sources)}. Ticket Statuses: {len(statuses)}. Priorities: {len(pr_out)}.",
+                            "success",
+                        )
+                        _log_admin_event(
+                            "autotask_reference_data_auto_refreshed",
+                            "Autotask reference data auto-refreshed after settings save.",
+                            details=json.dumps({"queues": len(queues or []), "ticket_sources": len(sources or []), "ticket_statuses": len(statuses or []), "priorities": len(pr_out)}),
+                        )
+            except Exception as exc:
+                try:
+                    db.session.rollback()
+                except Exception:
+                    pass
+                flash(f"Autotask reference data refresh failed: {exc}", "warning")
+                _log_admin_event(
+                    "autotask_reference_data_auto_refresh_failed",
+                    "Autotask reference data auto-refresh failed after settings save.",
+                    details=json.dumps({"error": str(exc)}),
+                )
+
             # If EML storage has been turned off, clear any stored blobs immediately.
             try:
                 if getattr(settings, "ingest_eml_retention_days", 7) == 0:
@@ -1308,6 +1352,77 @@ def settings_autotask_test_connection():
     return redirect(url_for("main.settings", section="integrations"))
 
 
+def _refresh_autotask_reference_data(settings):
+    """Refresh and persist Autotask reference data used for ticket default dropdowns."""
+    from ..integrations.autotask.client import AutotaskClient
+
+    client = AutotaskClient(
+        username=settings.autotask_api_username,
+        password=settings.autotask_api_password,
+        api_integration_code=settings.autotask_tracking_identifier,
+        environment=(settings.autotask_environment or "production"),
+    )
+
+    queues = client.get_queues()
+    sources = client.get_ticket_sources()
+    priorities = client.get_ticket_priorities()
+    statuses = client.get_ticket_statuses()
+
+    # Store a minimal subset for dropdowns (id + name/label)
+    # Note: Some "reference" values are exposed as picklists (value/label)
+    # instead of entity collections (id/name). We normalize both shapes.
+    def _norm(items):
+        out = []
+        for it in items or []:
+            if not isinstance(it, dict):
+                continue
+            _id = it.get("id")
+            if _id is None:
+                _id = it.get("value")
+
+            name = (
+                it.get("name")
+                or it.get("label")
+                or it.get("queueName")
+                or it.get("sourceName")
+                or it.get("description")
+                or ""
+            )
+            try:
+                _id_int = int(_id)
+            except Exception:
+                continue
+            out.append({"id": _id_int, "name": str(name)})
+        # Sort by name for stable dropdowns
+        out.sort(key=lambda x: (x.get("name") or "").lower())
+        return out
+
+    settings.autotask_cached_queues_json = json.dumps(_norm(queues))
+    settings.autotask_cached_ticket_sources_json = json.dumps(_norm(sources))
+    settings.autotask_cached_ticket_statuses_json = json.dumps(_norm(statuses))
+
+    # Priorities are returned as picklist values (value/label)
+    pr_out = []
+    for it in priorities or []:
+        if not isinstance(it, dict):
+            continue
+        if it.get("isActive") is False:
+            continue
+        val = it.get("value")
+        label = it.get("label") or it.get("name") or ""
+        try:
+            val_int = int(val)
+        except Exception:
+            continue
+        pr_out.append({"id": val_int, "name": str(label)})
+    pr_out.sort(key=lambda x: (x.get("name") or "").lower())
+
+    settings.autotask_cached_priorities_json = json.dumps(pr_out)
+    settings.autotask_reference_last_sync_at = datetime.utcnow()
+
+    return queues, sources, statuses, pr_out
+
+
 @main_bp.route("/settings/autotask/refresh-reference-data", methods=["POST"])
 @login_required
 @roles_required("admin")
@@ -1319,71 +1434,7 @@ def settings_autotask_refresh_reference_data():
         return redirect(url_for("main.settings", section="integrations"))
 
     try:
-        from ..integrations.autotask.client import AutotaskClient
-        client = AutotaskClient(
-            username=settings.autotask_api_username,
-            password=settings.autotask_api_password,
-            api_integration_code=settings.autotask_tracking_identifier,
-            environment=(settings.autotask_environment or "production"),
-        )
-
-        queues = client.get_queues()
-        sources = client.get_ticket_sources()
-        priorities = client.get_ticket_priorities()
-        statuses = client.get_ticket_statuses()
-
-        # Store a minimal subset for dropdowns (id + name/label)
-        # Note: Some "reference" values are exposed as picklists (value/label)
-        # instead of entity collections (id/name). We normalize both shapes.
-        def _norm(items):
-            out = []
-            for it in items or []:
-                if not isinstance(it, dict):
-                    continue
-                _id = it.get("id")
-                if _id is None:
-                    _id = it.get("value")
-
-                name = (
-                    it.get("name")
-                    or it.get("label")
-                    or it.get("queueName")
-                    or it.get("sourceName")
-                    or it.get("description")
-                    or ""
-                )
-                try:
-                    _id_int = int(_id)
-                except Exception:
-                    continue
-                out.append({"id": _id_int, "name": str(name)})
-            # Sort by name for stable dropdowns
-            out.sort(key=lambda x: (x.get("name") or "").lower())
-            return out
-
-        settings.autotask_cached_queues_json = json.dumps(_norm(queues))
-        settings.autotask_cached_ticket_sources_json = json.dumps(_norm(sources))
-        settings.autotask_cached_ticket_statuses_json = json.dumps(_norm(statuses))
-
-        # Priorities are returned as picklist values (value/label)
-        pr_out = []
-        for it in priorities or []:
-            if not isinstance(it, dict):
-                continue
-            if it.get("isActive") is False:
-                continue
-            val = it.get("value")
-            label = it.get("label") or it.get("name") or ""
-            try:
-                val_int = int(val)
-            except Exception:
-                continue
-            pr_out.append({"id": val_int, "name": str(label)})
-        pr_out.sort(key=lambda x: (x.get("name") or "").lower())
-
-        settings.autotask_cached_priorities_json = json.dumps(pr_out)
-        settings.autotask_reference_last_sync_at = datetime.utcnow()
-
+        queues, sources, statuses, pr_out = _refresh_autotask_reference_data(settings)
         db.session.commit()
 
         flash(

From 07e6630a899e451b4d734c2bd25eeb464474d1c4 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Mon, 19 Jan 2026 12:53:24 +0100
Subject: [PATCH 37/63] Auto-commit local changes before build (2026-01-19
 12:53:24)

---
 .last-branch                                  |   2 +-
 .../app/integrations/autotask/client.py       |  37 +++++
 .../src/backend/app/main/routes_run_checks.py | 133 ++++++++++++++----
 docs/changelog.md                             |  10 ++
 4 files changed, 152 insertions(+), 30 deletions(-)

diff --git a/.last-branch b/.last-branch
index a9c74c3..efacb08 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260119-03-autotask-reference-data-auto-refresh
+v20260119-04-autotask-ticket-registration
diff --git a/containers/backupchecks/src/backend/app/integrations/autotask/client.py b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
index 59a62f0..0382e41 100644
--- a/containers/backupchecks/src/backend/app/integrations/autotask/client.py
+++ b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
@@ -430,3 +430,40 @@ class AutotaskClient:
             return items[0]
 
         raise AutotaskError("Autotask did not return a created ticket object.")
+
+
+    def get_ticket(self, ticket_id: int) -> Dict[str, Any]:
+        """Retrieve a Ticket by Autotask Ticket ID.
+
+        Uses GET /Tickets/{id}.
+
+        This is the authoritative retrieval method and is mandatory after creation,
+        because the create response does not reliably include the human-facing
+        ticket number.
+        """
+
+        try:
+            tid = int(ticket_id)
+        except Exception:
+            raise AutotaskError("Invalid ticket id.")
+
+        if tid <= 0:
+            raise AutotaskError("Invalid ticket id.")
+
+        data = self._request("GET", f"Tickets/{tid}")
+        if isinstance(data, dict):
+            if "item" in data and isinstance(data.get("item"), dict):
+                return data["item"]
+            if "items" in data and isinstance(data.get("items"), list) and data.get("items"):
+                first = data.get("items")[0]
+                if isinstance(first, dict):
+                    return first
+            # Some environments return the raw object
+            if "id" in data or "ticketNumber" in data or "number" in data:
+                return data
+
+        items = self._as_items_list(data)
+        if items:
+            return items[0]
+
+        raise AutotaskError("Autotask did not return a ticket object.")
diff --git a/containers/backupchecks/src/backend/app/main/routes_run_checks.py b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
index b66350c..fb4120d 100644
--- a/containers/backupchecks/src/backend/app/main/routes_run_checks.py
+++ b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
@@ -35,6 +35,7 @@ from ..models import (
     Override,
     User,
 )
+from ..ticketing_utils import ensure_internal_ticket_for_job, ensure_ticket_jobrun_links
 
 
 def _build_autotask_client_from_settings():
@@ -894,16 +895,7 @@ def api_run_checks_create_autotask_ticket():
     if not run:
         return jsonify({"status": "error", "message": "Run not found."}), 404
 
-    # Idempotent: if already created, return existing linkage.
-    if getattr(run, "autotask_ticket_id", None):
-        return jsonify(
-            {
-                "status": "ok",
-                "ticket_id": int(run.autotask_ticket_id),
-                "ticket_number": getattr(run, "autotask_ticket_number", None) or "",
-                "already_exists": True,
-            }
-        )
+    already_exists = bool(getattr(run, "autotask_ticket_id", None))
 
     job = Job.query.get(run.job_id)
     if not job:
@@ -1002,42 +994,125 @@ def api_run_checks_create_autotask_ticket():
     if priority_id:
         payload["priority"] = int(priority_id)
 
+    client = None
     try:
         client = _build_autotask_client_from_settings()
-        created = client.create_ticket(payload)
     except Exception as exc:
-        return jsonify({"status": "error", "message": f"Autotask ticket creation failed: {exc}"}), 400
+        return jsonify({"status": "error", "message": f"Autotask client setup failed: {exc}"}), 400
 
-    ticket_id = created.get("id") if isinstance(created, dict) else None
-    ticket_number = None
-    if isinstance(created, dict):
-        ticket_number = created.get("ticketNumber") or created.get("number") or created.get("ticket_number")
+    ticket_id = getattr(run, "autotask_ticket_id", None)
+    ticket_number = getattr(run, "autotask_ticket_number", None)
 
+    # Create ticket only when missing.
     if not ticket_id:
-        return jsonify({"status": "error", "message": "Autotask did not return a ticket id."}), 400
+        try:
+            created = client.create_ticket(payload)
+        except Exception as exc:
+            return jsonify({"status": "error", "message": f"Autotask ticket creation failed: {exc}"}), 400
 
+        ticket_id = created.get("id") if isinstance(created, dict) else None
+        if isinstance(created, dict):
+            ticket_number = created.get("ticketNumber") or created.get("number") or created.get("ticket_number")
+
+        if not ticket_id:
+            return jsonify({"status": "error", "message": "Autotask did not return a ticket id."}), 400
+
+        try:
+            run.autotask_ticket_id = int(ticket_id)
+        except Exception:
+            run.autotask_ticket_id = None
+
+        run.autotask_ticket_number = (str(ticket_number).strip() if ticket_number is not None else "") or None
+        run.autotask_ticket_created_at = datetime.utcnow()
+        run.autotask_ticket_created_by_user_id = current_user.id
+
+        try:
+            db.session.add(run)
+            db.session.commit()
+        except Exception as exc:
+            db.session.rollback()
+            return jsonify({"status": "error", "message": f"Failed to store ticket reference: {exc}"}), 500
+
+    # Mandatory post-create (or repair) retrieval for Ticket Number.
+    if ticket_id and not (ticket_number or "").strip():
+        try:
+            fetched = client.get_ticket(int(ticket_id))
+            ticket_number = None
+            if isinstance(fetched, dict):
+                ticket_number = fetched.get("ticketNumber") or fetched.get("number") or fetched.get("ticket_number")
+            ticket_number = (str(ticket_number).strip() if ticket_number is not None else "") or None
+        except Exception as exc:
+            # Ticket ID is persisted, but internal propagation must not proceed without the ticket number.
+            return jsonify({"status": "error", "message": f"Autotask ticket created but ticket number retrieval failed: {exc}"}), 400
+
+        if not ticket_number:
+            return jsonify({"status": "error", "message": "Autotask ticket created but ticket number is not available."}), 400
+
+        try:
+            run = JobRun.query.get(run_id)
+            if not run:
+                return jsonify({"status": "error", "message": "Run not found."}), 404
+            run.autotask_ticket_number = ticket_number
+            db.session.add(run)
+            db.session.commit()
+        except Exception as exc:
+            db.session.rollback()
+            return jsonify({"status": "error", "message": f"Failed to store ticket number: {exc}"}), 500
+
+    # Internal ticket + linking propagation (required for UI parity)
     try:
-        run.autotask_ticket_id = int(ticket_id)
-    except Exception:
-        run.autotask_ticket_id = None
+        run = JobRun.query.get(run_id)
+        if not run:
+            return jsonify({"status": "error", "message": "Run not found."}), 404
 
-    run.autotask_ticket_number = (str(ticket_number).strip() if ticket_number is not None else "") or None
-    run.autotask_ticket_created_at = datetime.utcnow()
-    run.autotask_ticket_created_by_user_id = current_user.id
+        ticket_id_int = int(getattr(run, "autotask_ticket_id", None) or 0)
+        ticket_number_str = (getattr(run, "autotask_ticket_number", None) or "").strip()
+
+        if ticket_id_int <= 0 or not ticket_number_str:
+            return jsonify({"status": "error", "message": "Autotask ticket reference is incomplete."}), 400
+
+        # Create/reuse internal ticket (code == Autotask Ticket Number)
+        internal_ticket = ensure_internal_ticket_for_job(
+            ticket_code=ticket_number_str,
+            title=subject,
+            description=description,
+            job=job,
+            active_from_dt=getattr(run, "run_at", None) or datetime.utcnow(),
+            start_dt=getattr(run, "autotask_ticket_created_at", None) or datetime.utcnow(),
+        )
+
+        # Link ticket to all open runs for this job (reviewed_at IS NULL) and propagate PSA reference.
+        open_runs = JobRun.query.filter(JobRun.job_id == job.id, JobRun.reviewed_at.is_(None)).all()
+        run_ids_to_link: list[int] = []
+
+        for r in open_runs:
+            # Never overwrite an existing different Autotask ticket for a run.
+            existing_id = getattr(r, "autotask_ticket_id", None)
+            if existing_id and int(existing_id) != ticket_id_int:
+                continue
+
+            if not existing_id:
+                r.autotask_ticket_id = ticket_id_int
+                r.autotask_ticket_number = ticket_number_str
+                r.autotask_ticket_created_at = getattr(run, "autotask_ticket_created_at", None)
+                r.autotask_ticket_created_by_user_id = getattr(run, "autotask_ticket_created_by_user_id", None)
+                db.session.add(r)
+
+            run_ids_to_link.append(int(r.id))
+
+        ensure_ticket_jobrun_links(ticket_id=int(internal_ticket.id), run_ids=run_ids_to_link, link_source="autotask")
 
-    try:
-        db.session.add(run)
         db.session.commit()
     except Exception as exc:
         db.session.rollback()
-        return jsonify({"status": "error", "message": f"Failed to store ticket reference: {exc}"}), 500
+        return jsonify({"status": "error", "message": f"Failed to propagate internal ticket linkage: {exc}"}), 500
 
     return jsonify(
         {
             "status": "ok",
-            "ticket_id": int(run.autotask_ticket_id) if run.autotask_ticket_id else None,
-            "ticket_number": run.autotask_ticket_number or "",
-            "already_exists": False,
+            "ticket_id": int(getattr(run, "autotask_ticket_id", None) or 0) or None,
+            "ticket_number": getattr(run, "autotask_ticket_number", None) or "",
+            "already_exists": already_exists,
         }
     )
 
diff --git a/docs/changelog.md b/docs/changelog.md
index d7a846d..08516c9 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -223,6 +223,16 @@ Changes:
 - Aligned Autotask ticket creation and polling paths with the legacy manual ticket creation flow, without changing any UI behavior.
 - Ensured solution works consistently with Autotask integration enabled or disabled by relying exclusively on internal Ticket and TicketJobRun structures.
 
+## v20260119-04-autotask-ticket-registration
+
+### Changes:
+- Implemented reliable Autotask ticket number retrieval by enforcing a post-create GET on the created ticket, avoiding incomplete create responses.
+- Added automatic creation or reuse of an internal Ticket based on the Autotask ticket number to preserve legacy ticket behavior.
+- Ensured idempotent linking of the internal Ticket to all open job runs (reviewed_at IS NULL) for the same job, matching manual ticket functionality.
+- Propagated Autotask ticket references (autotask_ticket_id and autotask_ticket_number) to all related open runs when a ticket is created.
+- Added repair/propagation logic so runs that already have an Autotask ticket ID but lack internal linking are corrected automatically.
+- Guaranteed that future runs for the same job inherit the existing Autotask and internal ticket associations.
+
 ***
 
 ## v0.1.21

From d5e3734b35fd63203c7954d48fc15547eb0d3442 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Mon, 19 Jan 2026 13:15:08 +0100
Subject: [PATCH 38/63] Auto-commit local changes before build (2026-01-19
 13:15:08)

---
 .last-branch                                     |  2 +-
 .../backend/app/integrations/autotask/client.py  | 16 +++++++++++++++-
 docs/changelog.md                                |  8 ++++++++
 3 files changed, 24 insertions(+), 2 deletions(-)

diff --git a/.last-branch b/.last-branch
index efacb08..50bcf1d 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260119-04-autotask-ticket-registration
+v20260119-05-autotask-create-itemid
diff --git a/containers/backupchecks/src/backend/app/integrations/autotask/client.py b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
index 0382e41..61794db 100644
--- a/containers/backupchecks/src/backend/app/integrations/autotask/client.py
+++ b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
@@ -414,7 +414,10 @@ class AutotaskClient:
             raise AutotaskError("Ticket payload is empty.")
 
         data = self._request("POST", "Tickets", json_body=payload)
-        # Autotask commonly returns the created object or an items list.
+        # Autotask commonly returns only an itemId on create.
+        # We normalize that into a dict with an "id" key so callers can
+        # perform a follow-up GET /Tickets/{id} to retrieve the full object
+        # and the human-facing ticketNumber.
         if isinstance(data, dict):
             if "item" in data and isinstance(data.get("item"), dict):
                 return data["item"]
@@ -422,6 +425,17 @@ class AutotaskClient:
                 first = data.get("items")[0]
                 if isinstance(first, dict):
                     return first
+            # Autotask create responses often look like: {"itemId": 12345}
+            item_id = data.get("itemId")
+            if item_id is None:
+                item_id = data.get("itemID")
+            if item_id is not None:
+                try:
+                    tid = int(item_id)
+                except Exception:
+                    tid = 0
+                if tid > 0:
+                    return {"id": tid}
             if "id" in data:
                 return data
         # Fallback: return normalized first item if possible
diff --git a/docs/changelog.md b/docs/changelog.md
index 08516c9..2a3e9da 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -233,6 +233,14 @@ Changes:
 - Added repair/propagation logic so runs that already have an Autotask ticket ID but lack internal linking are corrected automatically.
 - Guaranteed that future runs for the same job inherit the existing Autotask and internal ticket associations.
 
+## v20260119-05-autotask-create-itemid
+
+### Changes:
+- Updated Autotask ticket creation handling to treat a POST response containing only {"itemId": <id>} as a successful ticket creation.
+- Normalized the create response so the returned itemId is mapped internally to a ticket id, ensuring the existing follow-up GET /Tickets/{id} flow is always executed.
+- Fixed erroneous failure condition where ticket creation was rejected because Autotask did not return a full ticket object.
+- Restored compatibility with Autotask’s documented behavior for ticket creation responses.
+
 ***
 
 ## v0.1.21

From 2887a021ba6039fe3bc65ff722e505d94e29f313 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Mon, 19 Jan 2026 13:20:41 +0100
Subject: [PATCH 39/63] Auto-commit local changes before build (2026-01-19
 13:20:41)

---
 .last-branch                                               | 2 +-
 containers/backupchecks/src/templates/main/run_checks.html | 4 ++--
 docs/changelog.md                                          | 7 +++++++
 3 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/.last-branch b/.last-branch
index 50bcf1d..558ed93 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260119-05-autotask-create-itemid
+v20260119-06-runchecks-renderRun-fix
diff --git a/containers/backupchecks/src/templates/main/run_checks.html b/containers/backupchecks/src/templates/main/run_checks.html
index 4701bb2..dcf56ca 100644
--- a/containers/backupchecks/src/templates/main/run_checks.html
+++ b/containers/backupchecks/src/templates/main/run_checks.html
@@ -901,7 +901,7 @@ table.addEventListener('change', function (e) {
                   for (var i = 0; i < runs.length; i++) {
                     if (String(runs[i].id) === String(keepRunId)) { idx = i; break; }
                   }
-                  renderModal(payload, idx);
+                  renderRun(payload, idx);
                 });
             }
           })
@@ -910,7 +910,7 @@ table.addEventListener('change', function (e) {
             else alert(e.message || 'Failed.');
           })
           .finally(function () {
-            // State will be recalculated by renderModal/renderRun.
+            // State will be recalculated by renderRun.
           });
         });
       }
diff --git a/docs/changelog.md b/docs/changelog.md
index 2a3e9da..97d6e7f 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -241,6 +241,13 @@ Changes:
 - Fixed erroneous failure condition where ticket creation was rejected because Autotask did not return a full ticket object.
 - Restored compatibility with Autotask’s documented behavior for ticket creation responses.
 
+## v20260119-06-runchecks-renderRun-fix
+
+### Changes:
+- Fixed JavaScript error in Run Checks where a non-existent renderModal() function was called after creating an Autotask ticket.
+- Replaced the invalid renderModal() call with renderRun() to correctly refresh the run state and UI.
+- Prevented UI failure after successful Autotask ticket creation while preserving backend behavior.
+
 ***
 
 ## v0.1.21

From d272d12d245defb3cd0a6c3b5fc32c4f5ce1e0ce Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Mon, 19 Jan 2026 13:31:09 +0100
Subject: [PATCH 40/63] Auto-commit local changes before build (2026-01-19
 13:31:09)

---
 .last-branch                                      |  2 +-
 .../src/backend/app/main/routes_run_checks.py     | 15 +++++++++++++++
 docs/changelog.md                                 |  8 ++++++++
 3 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/.last-branch b/.last-branch
index 558ed93..0dcaca2 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260119-06-runchecks-renderRun-fix
+v20260119-07-autotask-propagate-ticket-to-all-runs
diff --git a/containers/backupchecks/src/backend/app/main/routes_run_checks.py b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
index fb4120d..fc467cf 100644
--- a/containers/backupchecks/src/backend/app/main/routes_run_checks.py
+++ b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
@@ -1091,12 +1091,27 @@ def api_run_checks_create_autotask_ticket():
             if existing_id and int(existing_id) != ticket_id_int:
                 continue
 
+            # Ensure all open runs get BOTH the Autotask ticket id and number.
+            # Some runs may already have the id (indicator) but still miss the number.
             if not existing_id:
                 r.autotask_ticket_id = ticket_id_int
                 r.autotask_ticket_number = ticket_number_str
                 r.autotask_ticket_created_at = getattr(run, "autotask_ticket_created_at", None)
                 r.autotask_ticket_created_by_user_id = getattr(run, "autotask_ticket_created_by_user_id", None)
                 db.session.add(r)
+            else:
+                updated = False
+                if not (getattr(r, "autotask_ticket_number", None) or "").strip():
+                    r.autotask_ticket_number = ticket_number_str
+                    updated = True
+                if getattr(r, "autotask_ticket_created_at", None) is None:
+                    r.autotask_ticket_created_at = getattr(run, "autotask_ticket_created_at", None)
+                    updated = True
+                if getattr(r, "autotask_ticket_created_by_user_id", None) is None:
+                    r.autotask_ticket_created_by_user_id = getattr(run, "autotask_ticket_created_by_user_id", None)
+                    updated = True
+                if updated:
+                    db.session.add(r)
 
             run_ids_to_link.append(int(r.id))
 
diff --git a/docs/changelog.md b/docs/changelog.md
index 97d6e7f..aaa15ce 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -248,6 +248,14 @@ Changes:
 - Replaced the invalid renderModal() call with renderRun() to correctly refresh the run state and UI.
 - Prevented UI failure after successful Autotask ticket creation while preserving backend behavior.
 
+## v20260119-07-autotask-propagate-ticket-to-all-runs
+
+Changes:
+- Fixed ticket propagation logic so Autotask ticket numbers are applied to all open runs (reviewed_at IS NULL), not only the most recent run.
+- Ensured runs that already had an autotask_ticket_id but were missing the autotask_ticket_number are now correctly updated.
+- Restored legacy behavior where all active runs for the same job consistently display the linked ticket in Tickets, Tickets/Remarks, and Job Details.
+- Prevented partial ticket linkage that caused only the newest run to show the ticket number.
+
 ***
 
 ## v0.1.21

From c595c165ed8eb02197e89eaa4d4b4f5490092c97 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Mon, 19 Jan 2026 13:50:00 +0100
Subject: [PATCH 41/63] Auto-commit local changes before build (2026-01-19
 13:50:00)

---
 .last-branch                                             | 2 +-
 .../backupchecks/src/backend/app/main/routes_settings.py | 6 ++++--
 docs/changelog.md                                        | 9 ++++++++-
 3 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/.last-branch b/.last-branch
index 0dcaca2..5831d0b 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260119-07-autotask-propagate-ticket-to-all-runs
+v20260119-08-autotask-disable-toggle-persist
diff --git a/containers/backupchecks/src/backend/app/main/routes_settings.py b/containers/backupchecks/src/backend/app/main/routes_settings.py
index 96dba4d..d9d5764 100644
--- a/containers/backupchecks/src/backend/app/main/routes_settings.py
+++ b/containers/backupchecks/src/backend/app/main/routes_settings.py
@@ -435,8 +435,10 @@ def settings():
             settings.ui_timezone = (request.form.get("ui_timezone") or "").strip() or "Europe/Amsterdam"
 
         # Autotask integration
-        if "autotask_enabled" in request.form:
-            settings.autotask_enabled = bool(request.form.get("autotask_enabled"))
+        # Checkbox inputs are omitted from request.form when unchecked.
+        # Only apply the enabled toggle when the Autotask form was submitted.
+        if autotask_form_touched:
+            settings.autotask_enabled = "autotask_enabled" in request.form
 
         if "autotask_environment" in request.form:
             env_val = (request.form.get("autotask_environment") or "").strip().lower()
diff --git a/docs/changelog.md b/docs/changelog.md
index aaa15ce..0eb8996 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -250,12 +250,19 @@ Changes:
 
 ## v20260119-07-autotask-propagate-ticket-to-all-runs
 
-Changes:
+### Changes:
 - Fixed ticket propagation logic so Autotask ticket numbers are applied to all open runs (reviewed_at IS NULL), not only the most recent run.
 - Ensured runs that already had an autotask_ticket_id but were missing the autotask_ticket_number are now correctly updated.
 - Restored legacy behavior where all active runs for the same job consistently display the linked ticket in Tickets, Tickets/Remarks, and Job Details.
 - Prevented partial ticket linkage that caused only the newest run to show the ticket number.
 
+## v20260119-08-autotask-disable-toggle-persist
+
+### Changes:
+- Fixed persistence of the “Enable Autotask integration” setting so disabling the integration is correctly saved.
+- Updated form handling to explicitly set the Autotask enabled flag when the checkbox is unchecked, instead of implicitly keeping the previous value.
+- Prevented the Autotask integration from being automatically re-enabled after saving settings.
+
 ***
 
 ## v0.1.21

From c5ff1e11a346d902e053a6871d275d9517c4a23b Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Mon, 19 Jan 2026 14:06:42 +0100
Subject: [PATCH 42/63] Auto-commit local changes before build (2026-01-19
 14:06:42)

---
 .last-branch                                  |   2 +-
 .../src/backend/app/main/routes_run_checks.py | 152 ++++--------------
 .../src/templates/main/run_checks.html        |  66 +++++++-
 docs/changelog.md                             |   8 +
 4 files changed, 105 insertions(+), 123 deletions(-)

diff --git a/.last-branch b/.last-branch
index 5831d0b..e6aed7e 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260119-08-autotask-disable-toggle-persist
+v20260119-09-autotask-disabled-legacy-ticket-ui
diff --git a/containers/backupchecks/src/backend/app/main/routes_run_checks.py b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
index fc467cf..e1ba9a5 100644
--- a/containers/backupchecks/src/backend/app/main/routes_run_checks.py
+++ b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
@@ -35,7 +35,6 @@ from ..models import (
     Override,
     User,
 )
-from ..ticketing_utils import ensure_internal_ticket_for_job, ensure_ticket_jobrun_links
 
 
 def _build_autotask_client_from_settings():
@@ -697,11 +696,15 @@ def run_checks_page():
             }
         )
 
+    settings = _get_or_create_settings()
+    autotask_enabled = bool(getattr(settings, "autotask_enabled", False))
+
     return render_template(
         "main/run_checks.html",
         rows=payload,
         is_admin=(get_active_role() == "admin"),
         include_reviewed=include_reviewed,
+        autotask_enabled=autotask_enabled,
     )
 
 
@@ -895,7 +898,16 @@ def api_run_checks_create_autotask_ticket():
     if not run:
         return jsonify({"status": "error", "message": "Run not found."}), 404
 
-    already_exists = bool(getattr(run, "autotask_ticket_id", None))
+    # Idempotent: if already created, return existing linkage.
+    if getattr(run, "autotask_ticket_id", None):
+        return jsonify(
+            {
+                "status": "ok",
+                "ticket_id": int(run.autotask_ticket_id),
+                "ticket_number": getattr(run, "autotask_ticket_number", None) or "",
+                "already_exists": True,
+            }
+        )
 
     job = Job.query.get(run.job_id)
     if not job:
@@ -994,140 +1006,42 @@ def api_run_checks_create_autotask_ticket():
     if priority_id:
         payload["priority"] = int(priority_id)
 
-    client = None
     try:
         client = _build_autotask_client_from_settings()
+        created = client.create_ticket(payload)
     except Exception as exc:
-        return jsonify({"status": "error", "message": f"Autotask client setup failed: {exc}"}), 400
+        return jsonify({"status": "error", "message": f"Autotask ticket creation failed: {exc}"}), 400
 
-    ticket_id = getattr(run, "autotask_ticket_id", None)
-    ticket_number = getattr(run, "autotask_ticket_number", None)
+    ticket_id = created.get("id") if isinstance(created, dict) else None
+    ticket_number = None
+    if isinstance(created, dict):
+        ticket_number = created.get("ticketNumber") or created.get("number") or created.get("ticket_number")
 
-    # Create ticket only when missing.
     if not ticket_id:
-        try:
-            created = client.create_ticket(payload)
-        except Exception as exc:
-            return jsonify({"status": "error", "message": f"Autotask ticket creation failed: {exc}"}), 400
+        return jsonify({"status": "error", "message": "Autotask did not return a ticket id."}), 400
 
-        ticket_id = created.get("id") if isinstance(created, dict) else None
-        if isinstance(created, dict):
-            ticket_number = created.get("ticketNumber") or created.get("number") or created.get("ticket_number")
-
-        if not ticket_id:
-            return jsonify({"status": "error", "message": "Autotask did not return a ticket id."}), 400
-
-        try:
-            run.autotask_ticket_id = int(ticket_id)
-        except Exception:
-            run.autotask_ticket_id = None
-
-        run.autotask_ticket_number = (str(ticket_number).strip() if ticket_number is not None else "") or None
-        run.autotask_ticket_created_at = datetime.utcnow()
-        run.autotask_ticket_created_by_user_id = current_user.id
-
-        try:
-            db.session.add(run)
-            db.session.commit()
-        except Exception as exc:
-            db.session.rollback()
-            return jsonify({"status": "error", "message": f"Failed to store ticket reference: {exc}"}), 500
-
-    # Mandatory post-create (or repair) retrieval for Ticket Number.
-    if ticket_id and not (ticket_number or "").strip():
-        try:
-            fetched = client.get_ticket(int(ticket_id))
-            ticket_number = None
-            if isinstance(fetched, dict):
-                ticket_number = fetched.get("ticketNumber") or fetched.get("number") or fetched.get("ticket_number")
-            ticket_number = (str(ticket_number).strip() if ticket_number is not None else "") or None
-        except Exception as exc:
-            # Ticket ID is persisted, but internal propagation must not proceed without the ticket number.
-            return jsonify({"status": "error", "message": f"Autotask ticket created but ticket number retrieval failed: {exc}"}), 400
-
-        if not ticket_number:
-            return jsonify({"status": "error", "message": "Autotask ticket created but ticket number is not available."}), 400
-
-        try:
-            run = JobRun.query.get(run_id)
-            if not run:
-                return jsonify({"status": "error", "message": "Run not found."}), 404
-            run.autotask_ticket_number = ticket_number
-            db.session.add(run)
-            db.session.commit()
-        except Exception as exc:
-            db.session.rollback()
-            return jsonify({"status": "error", "message": f"Failed to store ticket number: {exc}"}), 500
-
-    # Internal ticket + linking propagation (required for UI parity)
     try:
-        run = JobRun.query.get(run_id)
-        if not run:
-            return jsonify({"status": "error", "message": "Run not found."}), 404
+        run.autotask_ticket_id = int(ticket_id)
+    except Exception:
+        run.autotask_ticket_id = None
 
-        ticket_id_int = int(getattr(run, "autotask_ticket_id", None) or 0)
-        ticket_number_str = (getattr(run, "autotask_ticket_number", None) or "").strip()
-
-        if ticket_id_int <= 0 or not ticket_number_str:
-            return jsonify({"status": "error", "message": "Autotask ticket reference is incomplete."}), 400
-
-        # Create/reuse internal ticket (code == Autotask Ticket Number)
-        internal_ticket = ensure_internal_ticket_for_job(
-            ticket_code=ticket_number_str,
-            title=subject,
-            description=description,
-            job=job,
-            active_from_dt=getattr(run, "run_at", None) or datetime.utcnow(),
-            start_dt=getattr(run, "autotask_ticket_created_at", None) or datetime.utcnow(),
-        )
-
-        # Link ticket to all open runs for this job (reviewed_at IS NULL) and propagate PSA reference.
-        open_runs = JobRun.query.filter(JobRun.job_id == job.id, JobRun.reviewed_at.is_(None)).all()
-        run_ids_to_link: list[int] = []
-
-        for r in open_runs:
-            # Never overwrite an existing different Autotask ticket for a run.
-            existing_id = getattr(r, "autotask_ticket_id", None)
-            if existing_id and int(existing_id) != ticket_id_int:
-                continue
-
-            # Ensure all open runs get BOTH the Autotask ticket id and number.
-            # Some runs may already have the id (indicator) but still miss the number.
-            if not existing_id:
-                r.autotask_ticket_id = ticket_id_int
-                r.autotask_ticket_number = ticket_number_str
-                r.autotask_ticket_created_at = getattr(run, "autotask_ticket_created_at", None)
-                r.autotask_ticket_created_by_user_id = getattr(run, "autotask_ticket_created_by_user_id", None)
-                db.session.add(r)
-            else:
-                updated = False
-                if not (getattr(r, "autotask_ticket_number", None) or "").strip():
-                    r.autotask_ticket_number = ticket_number_str
-                    updated = True
-                if getattr(r, "autotask_ticket_created_at", None) is None:
-                    r.autotask_ticket_created_at = getattr(run, "autotask_ticket_created_at", None)
-                    updated = True
-                if getattr(r, "autotask_ticket_created_by_user_id", None) is None:
-                    r.autotask_ticket_created_by_user_id = getattr(run, "autotask_ticket_created_by_user_id", None)
-                    updated = True
-                if updated:
-                    db.session.add(r)
-
-            run_ids_to_link.append(int(r.id))
-
-        ensure_ticket_jobrun_links(ticket_id=int(internal_ticket.id), run_ids=run_ids_to_link, link_source="autotask")
+    run.autotask_ticket_number = (str(ticket_number).strip() if ticket_number is not None else "") or None
+    run.autotask_ticket_created_at = datetime.utcnow()
+    run.autotask_ticket_created_by_user_id = current_user.id
 
+    try:
+        db.session.add(run)
         db.session.commit()
     except Exception as exc:
         db.session.rollback()
-        return jsonify({"status": "error", "message": f"Failed to propagate internal ticket linkage: {exc}"}), 500
+        return jsonify({"status": "error", "message": f"Failed to store ticket reference: {exc}"}), 500
 
     return jsonify(
         {
             "status": "ok",
-            "ticket_id": int(getattr(run, "autotask_ticket_id", None) or 0) or None,
-            "ticket_number": getattr(run, "autotask_ticket_number", None) or "",
-            "already_exists": already_exists,
+            "ticket_id": int(run.autotask_ticket_id) if run.autotask_ticket_id else None,
+            "ticket_number": run.autotask_ticket_number or "",
+            "already_exists": False,
         }
     )
 
diff --git a/containers/backupchecks/src/templates/main/run_checks.html b/containers/backupchecks/src/templates/main/run_checks.html
index dcf56ca..ef5f95d 100644
--- a/containers/backupchecks/src/templates/main/run_checks.html
+++ b/containers/backupchecks/src/templates/main/run_checks.html
@@ -216,12 +216,21 @@
                     <div class="row g-2 align-items-start">
 	                      <div class="col-12 col-lg-6">
 	                        <div class="border rounded p-2">
+	                          {% if autotask_enabled %}
 	                          <div class="d-flex align-items-center justify-content-between">
 	                            <div class="fw-semibold">Autotask ticket</div>
 	                            <button type="button" class="btn btn-sm btn-outline-primary" id="rcm_autotask_create">Create</button>
 	                          </div>
 	                          <div class="mt-2 small" id="rcm_autotask_info"></div>
 	                          <div class="mt-2 small text-muted" id="rcm_autotask_status"></div>
+	                          {% else %}
+	                          <div class="fw-semibold">New ticket</div>
+	                          <div class="d-flex gap-2 mt-1">
+	                            <input class="form-control form-control-sm" id="rcm_ticket_code" type="text" placeholder="Ticket number (e.g., T20260106.0001)" />
+	                            <button type="button" class="btn btn-sm btn-outline-primary" id="rcm_ticket_save">Add</button>
+	                          </div>
+	                          <div class="mt-1 small text-muted" id="rcm_ticket_status"></div>
+	                          {% endif %}
 	                        </div>
 	                      </div>
                       <div class="col-12 col-lg-6">
@@ -297,6 +306,8 @@
     var currentRunId = null;
     var currentPayload = null;
 
+    var autotaskEnabled = {{ 'true' if autotask_enabled else 'false' }};
+
     var btnMarkAllReviewed = document.getElementById('rcm_mark_all_reviewed');
     var btnMarkSuccessOverride = document.getElementById('rcm_mark_success_override');
 
@@ -843,17 +854,24 @@ table.addEventListener('change', function (e) {
       var atInfo = document.getElementById('rcm_autotask_info');
       var atStatus = document.getElementById('rcm_autotask_status');
 
+      var btnTicket = document.getElementById('rcm_ticket_save');
+      var tCode = document.getElementById('rcm_ticket_code');
+      var tStatus = document.getElementById('rcm_ticket_status');
+
       var btnRemark = document.getElementById('rcm_remark_save');
       var rBody = document.getElementById('rcm_remark_body');
       var rStatus = document.getElementById('rcm_remark_status');
 
       function clearStatus() {
         if (atStatus) atStatus.textContent = '';
+        if (tStatus) tStatus.textContent = '';
         if (rStatus) rStatus.textContent = '';
       }
 
       function setDisabled(disabled) {
         if (btnAutotask) btnAutotask.disabled = disabled;
+        if (btnTicket) btnTicket.disabled = disabled;
+        if (tCode) tCode.disabled = disabled;
         if (btnRemark) btnRemark.disabled = disabled;
         if (rBody) rBody.disabled = disabled;
       }
@@ -874,6 +892,42 @@ table.addEventListener('change', function (e) {
       }
       window.__rcmRenderAutotaskInfo = renderAutotaskInfo;
 
+      function isValidTicketCode(code) {
+        return /^T\d{8}\.\d{4}$/.test(code);
+      }
+
+      if (btnTicket) {
+        btnTicket.addEventListener('click', function () {
+          if (!currentRunId) { alert('Select a run first.'); return; }
+          clearStatus();
+          var ticket_code = tCode ? (tCode.value || '').trim().toUpperCase() : '';
+          if (!ticket_code) {
+            if (tStatus) tStatus.textContent = 'Ticket number is required.';
+            else alert('Ticket number is required.');
+            return;
+          }
+          if (!isValidTicketCode(ticket_code)) {
+            if (tStatus) tStatus.textContent = 'Invalid ticket number format. Expected TYYYYMMDD.####.';
+            else alert('Invalid ticket number format. Expected TYYYYMMDD.####.');
+            return;
+          }
+          if (tStatus) tStatus.textContent = 'Saving...';
+          apiJson('/api/tickets', {
+            method: 'POST',
+            body: JSON.stringify({job_run_id: currentRunId, ticket_code: ticket_code})
+          })
+          .then(function () {
+            if (tCode) tCode.value = '';
+            if (tStatus) tStatus.textContent = '';
+            loadAlerts(currentRunId);
+          })
+          .catch(function (e) {
+            if (tStatus) tStatus.textContent = e.message || 'Failed.';
+            else alert(e.message || 'Failed.');
+          });
+        });
+      }
+
       if (btnAutotask) {
         btnAutotask.addEventListener('click', function () {
           if (!currentRunId) { alert('Select a run first.'); return; }
@@ -901,7 +955,7 @@ table.addEventListener('change', function (e) {
                   for (var i = 0; i < runs.length; i++) {
                     if (String(runs[i].id) === String(keepRunId)) { idx = i; break; }
                   }
-                  renderRun(payload, idx);
+                  renderModal(payload, idx);
                 });
             }
           })
@@ -910,7 +964,7 @@ table.addEventListener('change', function (e) {
             else alert(e.message || 'Failed.');
           })
           .finally(function () {
-            // State will be recalculated by renderRun.
+            // State will be recalculated by renderModal/renderRun.
           });
         });
       }
@@ -977,7 +1031,13 @@ table.addEventListener('change', function (e) {
       currentRunId = run.id || null;
       if (window.__rcmClearCreateStatus) window.__rcmClearCreateStatus();
       if (window.__rcmRenderAutotaskInfo) window.__rcmRenderAutotaskInfo(run);
-      if (window.__rcmSetCreateDisabled) window.__rcmSetCreateDisabled(!currentRunId || !!run.autotask_ticket_id);
+      if (window.__rcmSetCreateDisabled) {
+        if (autotaskEnabled) {
+          window.__rcmSetCreateDisabled(!currentRunId || !!run.autotask_ticket_id);
+        } else {
+          window.__rcmSetCreateDisabled(!currentRunId);
+        }
+      }
       if (btnMarkSuccessOverride) {
         var _rs = (run.status || '').toString().toLowerCase();
         var _canOverride = !!currentRunId && !run.missed && (_rs.indexOf('override') === -1) && (_rs.indexOf('success') === -1);
diff --git a/docs/changelog.md b/docs/changelog.md
index 0eb8996..1c5e271 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -263,6 +263,14 @@ Changes:
 - Updated form handling to explicitly set the Autotask enabled flag when the checkbox is unchecked, instead of implicitly keeping the previous value.
 - Prevented the Autotask integration from being automatically re-enabled after saving settings.
 
+## v20260119-09-autotask-disabled-legacy-ticket-ui
+
+### Changes:
+- Restored the legacy manual ticket registration UI when the Autotask integration is disabled.
+- Updated Run Checks to switch the ticket creation interface based solely on the autotask_enabled setting.
+- Hidden the Autotask ticket creation section entirely when the integration is turned off.
+- Re-enabled the original legacy ticket creation flow to allow correct Ticket and TicketJobRun linking without Autotask.
+
 ***
 
 ## v0.1.21

From 890553f23ed9b3b05b90e86a76175795d53c49b0 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Mon, 19 Jan 2026 14:18:29 +0100
Subject: [PATCH 43/63] Auto-commit local changes before build (2026-01-19
 14:18:29)

---
 .last-branch                                              | 2 +-
 .../backupchecks/src/templates/main/run_checks.html       | 4 ++--
 docs/changelog.md                                         | 8 ++++++++
 3 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/.last-branch b/.last-branch
index e6aed7e..e8abf56 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260119-09-autotask-disabled-legacy-ticket-ui
+v20260119-10-runchecks-renderRun-alias
diff --git a/containers/backupchecks/src/templates/main/run_checks.html b/containers/backupchecks/src/templates/main/run_checks.html
index ef5f95d..cc5f532 100644
--- a/containers/backupchecks/src/templates/main/run_checks.html
+++ b/containers/backupchecks/src/templates/main/run_checks.html
@@ -955,7 +955,7 @@ table.addEventListener('change', function (e) {
                   for (var i = 0; i < runs.length; i++) {
                     if (String(runs[i].id) === String(keepRunId)) { idx = i; break; }
                   }
-                  renderModal(payload, idx);
+                  renderRun(payload, idx);
                 });
             }
           })
@@ -964,7 +964,7 @@ table.addEventListener('change', function (e) {
             else alert(e.message || 'Failed.');
           })
           .finally(function () {
-            // State will be recalculated by renderModal/renderRun.
+            // State will be recalculated by renderRun.
           });
         });
       }
diff --git a/docs/changelog.md b/docs/changelog.md
index 1c5e271..4e24a7e 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -271,6 +271,14 @@ Changes:
 - Hidden the Autotask ticket creation section entirely when the integration is turned off.
 - Re-enabled the original legacy ticket creation flow to allow correct Ticket and TicketJobRun linking without Autotask.
 
+
+## v20260119-10-runchecks-renderRun-alias
+
+### Changes:
+- Fixed remaining JavaScript references to the non-existent renderModal() function in the Run Checks flow.
+- Ensured consistent use of renderRun() when toggling the Autotask integration on and off.
+- Prevented UI errors when re-enabling the Autotask integration after it was disabled.
+
 ***
 
 ## v0.1.21

From 0500491621c7310f432e30d9b44b1273ac104f84 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Mon, 19 Jan 2026 14:23:56 +0100
Subject: [PATCH 44/63] Auto-commit local changes before build (2026-01-19
 14:23:56)

---
 .last-branch                                  |   2 +-
 .../src/backend/app/main/routes_run_checks.py | 137 +++++++++++++-----
 .../src/backend/app/main/routes_settings.py   |   6 +-
 .../src/templates/main/run_checks.html        |  62 +-------
 4 files changed, 108 insertions(+), 99 deletions(-)

diff --git a/.last-branch b/.last-branch
index e8abf56..cd2955b 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260119-10-runchecks-renderRun-alias
+v20260119-11-restoredto--v20260119-06-runchecks-renderRun-fix
diff --git a/containers/backupchecks/src/backend/app/main/routes_run_checks.py b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
index e1ba9a5..fb4120d 100644
--- a/containers/backupchecks/src/backend/app/main/routes_run_checks.py
+++ b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
@@ -35,6 +35,7 @@ from ..models import (
     Override,
     User,
 )
+from ..ticketing_utils import ensure_internal_ticket_for_job, ensure_ticket_jobrun_links
 
 
 def _build_autotask_client_from_settings():
@@ -696,15 +697,11 @@ def run_checks_page():
             }
         )
 
-    settings = _get_or_create_settings()
-    autotask_enabled = bool(getattr(settings, "autotask_enabled", False))
-
     return render_template(
         "main/run_checks.html",
         rows=payload,
         is_admin=(get_active_role() == "admin"),
         include_reviewed=include_reviewed,
-        autotask_enabled=autotask_enabled,
     )
 
 
@@ -898,16 +895,7 @@ def api_run_checks_create_autotask_ticket():
     if not run:
         return jsonify({"status": "error", "message": "Run not found."}), 404
 
-    # Idempotent: if already created, return existing linkage.
-    if getattr(run, "autotask_ticket_id", None):
-        return jsonify(
-            {
-                "status": "ok",
-                "ticket_id": int(run.autotask_ticket_id),
-                "ticket_number": getattr(run, "autotask_ticket_number", None) or "",
-                "already_exists": True,
-            }
-        )
+    already_exists = bool(getattr(run, "autotask_ticket_id", None))
 
     job = Job.query.get(run.job_id)
     if not job:
@@ -1006,42 +994,125 @@ def api_run_checks_create_autotask_ticket():
     if priority_id:
         payload["priority"] = int(priority_id)
 
+    client = None
     try:
         client = _build_autotask_client_from_settings()
-        created = client.create_ticket(payload)
     except Exception as exc:
-        return jsonify({"status": "error", "message": f"Autotask ticket creation failed: {exc}"}), 400
+        return jsonify({"status": "error", "message": f"Autotask client setup failed: {exc}"}), 400
 
-    ticket_id = created.get("id") if isinstance(created, dict) else None
-    ticket_number = None
-    if isinstance(created, dict):
-        ticket_number = created.get("ticketNumber") or created.get("number") or created.get("ticket_number")
+    ticket_id = getattr(run, "autotask_ticket_id", None)
+    ticket_number = getattr(run, "autotask_ticket_number", None)
 
+    # Create ticket only when missing.
     if not ticket_id:
-        return jsonify({"status": "error", "message": "Autotask did not return a ticket id."}), 400
+        try:
+            created = client.create_ticket(payload)
+        except Exception as exc:
+            return jsonify({"status": "error", "message": f"Autotask ticket creation failed: {exc}"}), 400
 
+        ticket_id = created.get("id") if isinstance(created, dict) else None
+        if isinstance(created, dict):
+            ticket_number = created.get("ticketNumber") or created.get("number") or created.get("ticket_number")
+
+        if not ticket_id:
+            return jsonify({"status": "error", "message": "Autotask did not return a ticket id."}), 400
+
+        try:
+            run.autotask_ticket_id = int(ticket_id)
+        except Exception:
+            run.autotask_ticket_id = None
+
+        run.autotask_ticket_number = (str(ticket_number).strip() if ticket_number is not None else "") or None
+        run.autotask_ticket_created_at = datetime.utcnow()
+        run.autotask_ticket_created_by_user_id = current_user.id
+
+        try:
+            db.session.add(run)
+            db.session.commit()
+        except Exception as exc:
+            db.session.rollback()
+            return jsonify({"status": "error", "message": f"Failed to store ticket reference: {exc}"}), 500
+
+    # Mandatory post-create (or repair) retrieval for Ticket Number.
+    if ticket_id and not (ticket_number or "").strip():
+        try:
+            fetched = client.get_ticket(int(ticket_id))
+            ticket_number = None
+            if isinstance(fetched, dict):
+                ticket_number = fetched.get("ticketNumber") or fetched.get("number") or fetched.get("ticket_number")
+            ticket_number = (str(ticket_number).strip() if ticket_number is not None else "") or None
+        except Exception as exc:
+            # Ticket ID is persisted, but internal propagation must not proceed without the ticket number.
+            return jsonify({"status": "error", "message": f"Autotask ticket created but ticket number retrieval failed: {exc}"}), 400
+
+        if not ticket_number:
+            return jsonify({"status": "error", "message": "Autotask ticket created but ticket number is not available."}), 400
+
+        try:
+            run = JobRun.query.get(run_id)
+            if not run:
+                return jsonify({"status": "error", "message": "Run not found."}), 404
+            run.autotask_ticket_number = ticket_number
+            db.session.add(run)
+            db.session.commit()
+        except Exception as exc:
+            db.session.rollback()
+            return jsonify({"status": "error", "message": f"Failed to store ticket number: {exc}"}), 500
+
+    # Internal ticket + linking propagation (required for UI parity)
     try:
-        run.autotask_ticket_id = int(ticket_id)
-    except Exception:
-        run.autotask_ticket_id = None
+        run = JobRun.query.get(run_id)
+        if not run:
+            return jsonify({"status": "error", "message": "Run not found."}), 404
 
-    run.autotask_ticket_number = (str(ticket_number).strip() if ticket_number is not None else "") or None
-    run.autotask_ticket_created_at = datetime.utcnow()
-    run.autotask_ticket_created_by_user_id = current_user.id
+        ticket_id_int = int(getattr(run, "autotask_ticket_id", None) or 0)
+        ticket_number_str = (getattr(run, "autotask_ticket_number", None) or "").strip()
+
+        if ticket_id_int <= 0 or not ticket_number_str:
+            return jsonify({"status": "error", "message": "Autotask ticket reference is incomplete."}), 400
+
+        # Create/reuse internal ticket (code == Autotask Ticket Number)
+        internal_ticket = ensure_internal_ticket_for_job(
+            ticket_code=ticket_number_str,
+            title=subject,
+            description=description,
+            job=job,
+            active_from_dt=getattr(run, "run_at", None) or datetime.utcnow(),
+            start_dt=getattr(run, "autotask_ticket_created_at", None) or datetime.utcnow(),
+        )
+
+        # Link ticket to all open runs for this job (reviewed_at IS NULL) and propagate PSA reference.
+        open_runs = JobRun.query.filter(JobRun.job_id == job.id, JobRun.reviewed_at.is_(None)).all()
+        run_ids_to_link: list[int] = []
+
+        for r in open_runs:
+            # Never overwrite an existing different Autotask ticket for a run.
+            existing_id = getattr(r, "autotask_ticket_id", None)
+            if existing_id and int(existing_id) != ticket_id_int:
+                continue
+
+            if not existing_id:
+                r.autotask_ticket_id = ticket_id_int
+                r.autotask_ticket_number = ticket_number_str
+                r.autotask_ticket_created_at = getattr(run, "autotask_ticket_created_at", None)
+                r.autotask_ticket_created_by_user_id = getattr(run, "autotask_ticket_created_by_user_id", None)
+                db.session.add(r)
+
+            run_ids_to_link.append(int(r.id))
+
+        ensure_ticket_jobrun_links(ticket_id=int(internal_ticket.id), run_ids=run_ids_to_link, link_source="autotask")
 
-    try:
-        db.session.add(run)
         db.session.commit()
     except Exception as exc:
         db.session.rollback()
-        return jsonify({"status": "error", "message": f"Failed to store ticket reference: {exc}"}), 500
+        return jsonify({"status": "error", "message": f"Failed to propagate internal ticket linkage: {exc}"}), 500
 
     return jsonify(
         {
             "status": "ok",
-            "ticket_id": int(run.autotask_ticket_id) if run.autotask_ticket_id else None,
-            "ticket_number": run.autotask_ticket_number or "",
-            "already_exists": False,
+            "ticket_id": int(getattr(run, "autotask_ticket_id", None) or 0) or None,
+            "ticket_number": getattr(run, "autotask_ticket_number", None) or "",
+            "already_exists": already_exists,
         }
     )
 
diff --git a/containers/backupchecks/src/backend/app/main/routes_settings.py b/containers/backupchecks/src/backend/app/main/routes_settings.py
index d9d5764..96dba4d 100644
--- a/containers/backupchecks/src/backend/app/main/routes_settings.py
+++ b/containers/backupchecks/src/backend/app/main/routes_settings.py
@@ -435,10 +435,8 @@ def settings():
             settings.ui_timezone = (request.form.get("ui_timezone") or "").strip() or "Europe/Amsterdam"
 
         # Autotask integration
-        # Checkbox inputs are omitted from request.form when unchecked.
-        # Only apply the enabled toggle when the Autotask form was submitted.
-        if autotask_form_touched:
-            settings.autotask_enabled = "autotask_enabled" in request.form
+        if "autotask_enabled" in request.form:
+            settings.autotask_enabled = bool(request.form.get("autotask_enabled"))
 
         if "autotask_environment" in request.form:
             env_val = (request.form.get("autotask_environment") or "").strip().lower()
diff --git a/containers/backupchecks/src/templates/main/run_checks.html b/containers/backupchecks/src/templates/main/run_checks.html
index cc5f532..dcf56ca 100644
--- a/containers/backupchecks/src/templates/main/run_checks.html
+++ b/containers/backupchecks/src/templates/main/run_checks.html
@@ -216,21 +216,12 @@
                     <div class="row g-2 align-items-start">
 	                      <div class="col-12 col-lg-6">
 	                        <div class="border rounded p-2">
-	                          {% if autotask_enabled %}
 	                          <div class="d-flex align-items-center justify-content-between">
 	                            <div class="fw-semibold">Autotask ticket</div>
 	                            <button type="button" class="btn btn-sm btn-outline-primary" id="rcm_autotask_create">Create</button>
 	                          </div>
 	                          <div class="mt-2 small" id="rcm_autotask_info"></div>
 	                          <div class="mt-2 small text-muted" id="rcm_autotask_status"></div>
-	                          {% else %}
-	                          <div class="fw-semibold">New ticket</div>
-	                          <div class="d-flex gap-2 mt-1">
-	                            <input class="form-control form-control-sm" id="rcm_ticket_code" type="text" placeholder="Ticket number (e.g., T20260106.0001)" />
-	                            <button type="button" class="btn btn-sm btn-outline-primary" id="rcm_ticket_save">Add</button>
-	                          </div>
-	                          <div class="mt-1 small text-muted" id="rcm_ticket_status"></div>
-	                          {% endif %}
 	                        </div>
 	                      </div>
                       <div class="col-12 col-lg-6">
@@ -306,8 +297,6 @@
     var currentRunId = null;
     var currentPayload = null;
 
-    var autotaskEnabled = {{ 'true' if autotask_enabled else 'false' }};
-
     var btnMarkAllReviewed = document.getElementById('rcm_mark_all_reviewed');
     var btnMarkSuccessOverride = document.getElementById('rcm_mark_success_override');
 
@@ -854,24 +843,17 @@ table.addEventListener('change', function (e) {
       var atInfo = document.getElementById('rcm_autotask_info');
       var atStatus = document.getElementById('rcm_autotask_status');
 
-      var btnTicket = document.getElementById('rcm_ticket_save');
-      var tCode = document.getElementById('rcm_ticket_code');
-      var tStatus = document.getElementById('rcm_ticket_status');
-
       var btnRemark = document.getElementById('rcm_remark_save');
       var rBody = document.getElementById('rcm_remark_body');
       var rStatus = document.getElementById('rcm_remark_status');
 
       function clearStatus() {
         if (atStatus) atStatus.textContent = '';
-        if (tStatus) tStatus.textContent = '';
         if (rStatus) rStatus.textContent = '';
       }
 
       function setDisabled(disabled) {
         if (btnAutotask) btnAutotask.disabled = disabled;
-        if (btnTicket) btnTicket.disabled = disabled;
-        if (tCode) tCode.disabled = disabled;
         if (btnRemark) btnRemark.disabled = disabled;
         if (rBody) rBody.disabled = disabled;
       }
@@ -892,42 +874,6 @@ table.addEventListener('change', function (e) {
       }
       window.__rcmRenderAutotaskInfo = renderAutotaskInfo;
 
-      function isValidTicketCode(code) {
-        return /^T\d{8}\.\d{4}$/.test(code);
-      }
-
-      if (btnTicket) {
-        btnTicket.addEventListener('click', function () {
-          if (!currentRunId) { alert('Select a run first.'); return; }
-          clearStatus();
-          var ticket_code = tCode ? (tCode.value || '').trim().toUpperCase() : '';
-          if (!ticket_code) {
-            if (tStatus) tStatus.textContent = 'Ticket number is required.';
-            else alert('Ticket number is required.');
-            return;
-          }
-          if (!isValidTicketCode(ticket_code)) {
-            if (tStatus) tStatus.textContent = 'Invalid ticket number format. Expected TYYYYMMDD.####.';
-            else alert('Invalid ticket number format. Expected TYYYYMMDD.####.');
-            return;
-          }
-          if (tStatus) tStatus.textContent = 'Saving...';
-          apiJson('/api/tickets', {
-            method: 'POST',
-            body: JSON.stringify({job_run_id: currentRunId, ticket_code: ticket_code})
-          })
-          .then(function () {
-            if (tCode) tCode.value = '';
-            if (tStatus) tStatus.textContent = '';
-            loadAlerts(currentRunId);
-          })
-          .catch(function (e) {
-            if (tStatus) tStatus.textContent = e.message || 'Failed.';
-            else alert(e.message || 'Failed.');
-          });
-        });
-      }
-
       if (btnAutotask) {
         btnAutotask.addEventListener('click', function () {
           if (!currentRunId) { alert('Select a run first.'); return; }
@@ -1031,13 +977,7 @@ table.addEventListener('change', function (e) {
       currentRunId = run.id || null;
       if (window.__rcmClearCreateStatus) window.__rcmClearCreateStatus();
       if (window.__rcmRenderAutotaskInfo) window.__rcmRenderAutotaskInfo(run);
-      if (window.__rcmSetCreateDisabled) {
-        if (autotaskEnabled) {
-          window.__rcmSetCreateDisabled(!currentRunId || !!run.autotask_ticket_id);
-        } else {
-          window.__rcmSetCreateDisabled(!currentRunId);
-        }
-      }
+      if (window.__rcmSetCreateDisabled) window.__rcmSetCreateDisabled(!currentRunId || !!run.autotask_ticket_id);
       if (btnMarkSuccessOverride) {
         var _rs = (run.status || '').toString().toLowerCase();
         var _canOverride = !!currentRunId && !run.missed && (_rs.indexOf('override') === -1) && (_rs.indexOf('success') === -1);

From 0c5dee307fc0ae18da576ce7ab8525a1f00c39b4 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Mon, 19 Jan 2026 14:50:02 +0100
Subject: [PATCH 45/63] Auto-commit local changes before build (2026-01-19
 14:50:02)

---
 .last-branch                                  |   2 +-
 .../app/integrations/autotask/client.py       |  57 +++
 .../src/backend/app/main/routes_run_checks.py | 404 +++++++++++++-----
 docs/changelog.md                             |  11 +
 4 files changed, 369 insertions(+), 105 deletions(-)

diff --git a/.last-branch b/.last-branch
index cd2955b..ded7de3 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260119-11-restoredto--v20260119-06-runchecks-renderRun-fix
+v20260119-12-autotask-ticket-state-sync
diff --git a/containers/backupchecks/src/backend/app/integrations/autotask/client.py b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
index 61794db..4aaaa8a 100644
--- a/containers/backupchecks/src/backend/app/integrations/autotask/client.py
+++ b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
@@ -481,3 +481,60 @@ class AutotaskClient:
             return items[0]
 
         raise AutotaskError("Autotask did not return a ticket object.")
+
+
+    def query_tickets_by_ids(
+        self,
+        ticket_ids: List[int],
+        *,
+        exclude_status_ids: Optional[List[int]] = None,
+    ) -> List[Dict[str, Any]]:
+        """Query Tickets by ID, optionally excluding statuses.
+
+        Uses POST /Tickets/query.
+
+        Note:
+        - This endpoint is not authoritative (tickets can be missing).
+        - Call get_ticket(id) as a fallback for missing IDs.
+        """
+
+        ids: List[int] = []
+        for x in ticket_ids or []:
+            try:
+                v = int(x)
+            except Exception:
+                continue
+            if v > 0:
+                ids.append(v)
+
+        if not ids:
+            return []
+
+        flt: List[Dict[str, Any]] = [
+            {
+                "op": "in",
+                "field": "id",
+                "value": ids,
+            }
+        ]
+
+        ex: List[int] = []
+        for x in exclude_status_ids or []:
+            try:
+                v = int(x)
+            except Exception:
+                continue
+            if v > 0:
+                ex.append(v)
+
+        if ex:
+            flt.append(
+                {
+                    "op": "notIn",
+                    "field": "status",
+                    "value": ex,
+                }
+            )
+
+        data = self._request("POST", "Tickets/query", json_body={"filter": flt})
+        return self._as_items_list(data)
diff --git a/containers/backupchecks/src/backend/app/main/routes_run_checks.py b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
index fb4120d..bb07517 100644
--- a/containers/backupchecks/src/backend/app/main/routes_run_checks.py
+++ b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
@@ -33,9 +33,266 @@ from ..models import (
     MailMessage,
     MailObject,
     Override,
+    Ticket,
+    TicketJobRun,
+    TicketScope,
     User,
 )
-from ..ticketing_utils import ensure_internal_ticket_for_job, ensure_ticket_jobrun_links
+
+
+AUTOTASK_TERMINAL_STATUS_IDS = {5}
+
+
+def _ensure_internal_ticket_for_autotask(
+    *,
+    ticket_number: str,
+    job: Job | None,
+    run_ids: list[int],
+    now: datetime,
+) -> Ticket | None:
+    """Best-effort: ensure an internal Ticket exists and is linked to the provided runs."""
+
+    code = (ticket_number or "").strip().upper()
+    if not code:
+        return None
+
+    ticket = Ticket.query.filter(Ticket.ticket_code == code).first()
+
+    if ticket is None:
+        # Align with manual ticket creation: active_from_date is today (Amsterdam date).
+        active_from = _to_amsterdam_date(now) or now.date()
+        ticket = Ticket(
+            ticket_code=code,
+            description="",
+            active_from_date=active_from,
+            start_date=now,
+        )
+        db.session.add(ticket)
+        db.session.flush()
+
+    # Ensure job scope exists (for Daily Jobs / Job Details filtering), best-effort.
+    if job is not None and getattr(job, "id", None):
+        try:
+            existing = TicketScope.query.filter_by(ticket_id=ticket.id, scope_type="job", job_id=job.id).first()
+            if existing is None:
+                db.session.add(
+                    TicketScope(
+                        ticket_id=ticket.id,
+                        scope_type="job",
+                        customer_id=job.customer_id,
+                        backup_software=job.backup_software,
+                        backup_type=job.backup_type,
+                        job_id=job.id,
+                        job_name_match=job.job_name,
+                        job_name_match_mode="exact",
+                    )
+                )
+        except Exception:
+            pass
+
+    # Ensure run links.
+    for rid in run_ids or []:
+        if rid <= 0:
+            continue
+        if not TicketJobRun.query.filter_by(ticket_id=ticket.id, job_run_id=rid).first():
+            db.session.add(TicketJobRun(ticket_id=ticket.id, job_run_id=rid, link_source="autotask"))
+
+    return ticket
+
+
+def _resolve_internal_ticket_for_job(
+    *,
+    ticket: Ticket,
+    job: Job | None,
+    run_ids: list[int],
+    now: datetime,
+) -> None:
+    """Resolve the ticket (and its job scope) as PSA-driven, best-effort."""
+
+    if ticket.resolved_at is None:
+        ticket.resolved_at = now
+
+    # Resolve all still-open scopes.
+    try:
+        TicketScope.query.filter_by(ticket_id=ticket.id, resolved_at=None).update({"resolved_at": now})
+    except Exception:
+        pass
+
+    # Ensure job scope exists and is resolved.
+    if job is not None and getattr(job, "id", None):
+        try:
+            scope = TicketScope.query.filter_by(ticket_id=ticket.id, scope_type="job", job_id=job.id).first()
+            if scope is None:
+                scope = TicketScope(
+                    ticket_id=ticket.id,
+                    scope_type="job",
+                    customer_id=job.customer_id,
+                    backup_software=job.backup_software,
+                    backup_type=job.backup_type,
+                    job_id=job.id,
+                    job_name_match=job.job_name,
+                    job_name_match_mode="exact",
+                    resolved_at=now,
+                )
+                db.session.add(scope)
+            else:
+                if scope.resolved_at is None:
+                    scope.resolved_at = now
+        except Exception:
+            pass
+
+    # Keep audit links to runs.
+    for rid in run_ids or []:
+        if rid <= 0:
+            continue
+        if not TicketJobRun.query.filter_by(ticket_id=ticket.id, job_run_id=rid).first():
+            db.session.add(TicketJobRun(ticket_id=ticket.id, job_run_id=rid, link_source="autotask"))
+
+
+def _poll_autotask_ticket_states_for_runs(*, run_ids: list[int]) -> None:
+    """Phase 2: Read-only PSA-driven ticket completion sync.
+
+    Best-effort: never blocks page load.
+    """
+
+    if not run_ids:
+        return
+
+    settings = _get_or_create_settings()
+    if not bool(getattr(settings, "autotask_enabled", False)):
+        return
+
+    # Build ticket id -> run ids mapping.
+    runs = JobRun.query.filter(JobRun.id.in_(run_ids)).all()
+    ticket_to_runs: dict[int, list[JobRun]] = {}
+    for r in runs:
+        tid = getattr(r, "autotask_ticket_id", None)
+        try:
+            tid_int = int(tid) if tid is not None else 0
+        except Exception:
+            tid_int = 0
+        if tid_int <= 0:
+            continue
+        ticket_to_runs.setdefault(tid_int, []).append(r)
+
+    if not ticket_to_runs:
+        return
+
+    try:
+        client = _build_autotask_client_from_settings()
+    except Exception:
+        return
+
+    now = datetime.utcnow()
+    ticket_ids = sorted(ticket_to_runs.keys())
+
+    # Optimization: query non-terminal tickets first; fallback to GET by id for missing.
+    try:
+        active_items = client.query_tickets_by_ids(ticket_ids, exclude_status_ids=sorted(AUTOTASK_TERMINAL_STATUS_IDS))
+    except Exception:
+        active_items = []
+
+    active_map: dict[int, dict] = {}
+    for it in active_items or []:
+        try:
+            iid = int(it.get("id") or 0)
+        except Exception:
+            iid = 0
+        if iid > 0:
+            active_map[iid] = it
+
+    missing_ids = [tid for tid in ticket_ids if tid not in active_map]
+
+    # Process active tickets: backfill ticket numbers + ensure internal ticket link.
+    try:
+        for tid, item in active_map.items():
+            runs_for_ticket = ticket_to_runs.get(tid) or []
+            ticket_number = None
+            if isinstance(item, dict):
+                ticket_number = item.get("ticketNumber") or item.get("number") or item.get("ticket_number")
+            # Backfill missing stored ticket number.
+            if ticket_number:
+                for rr in runs_for_ticket:
+                    if not (getattr(rr, "autotask_ticket_number", None) or "").strip():
+                        rr.autotask_ticket_number = str(ticket_number).strip()
+                        db.session.add(rr)
+
+            # Ensure internal ticket exists and is linked.
+            tn = (str(ticket_number).strip() if ticket_number else "")
+            if not tn:
+                # Try from DB
+                for rr in runs_for_ticket:
+                    if (getattr(rr, "autotask_ticket_number", None) or "").strip():
+                        tn = rr.autotask_ticket_number.strip()
+                        break
+
+            job = Job.query.get(runs_for_ticket[0].job_id) if runs_for_ticket else None
+            _ensure_internal_ticket_for_autotask(
+                ticket_number=tn,
+                job=job,
+                run_ids=[int(x.id) for x in runs_for_ticket if getattr(x, "id", None)],
+                now=now,
+            )
+    except Exception:
+        # Continue to missing-id fallback.
+        pass
+
+    # Fallback for missing ids (could be terminal, deleted, or query omission).
+    for tid in missing_ids:
+        try:
+            t = client.get_ticket(tid)
+        except Exception:
+            continue
+
+        status_id = None
+        if isinstance(t, dict):
+            status_id = t.get("status") or t.get("statusId") or t.get("statusID")
+        try:
+            status_int = int(status_id) if status_id is not None else 0
+        except Exception:
+            status_int = 0
+
+        ticket_number = None
+        if isinstance(t, dict):
+            ticket_number = t.get("ticketNumber") or t.get("number") or t.get("ticket_number")
+
+        runs_for_ticket = ticket_to_runs.get(tid) or []
+        # Backfill stored ticket number if missing.
+        if ticket_number:
+            for rr in runs_for_ticket:
+                if not (getattr(rr, "autotask_ticket_number", None) or "").strip():
+                    rr.autotask_ticket_number = str(ticket_number).strip()
+                    db.session.add(rr)
+
+        job = Job.query.get(runs_for_ticket[0].job_id) if runs_for_ticket else None
+
+        tn = (str(ticket_number).strip() if ticket_number else "")
+        if not tn:
+            for rr in runs_for_ticket:
+                if (getattr(rr, "autotask_ticket_number", None) or "").strip():
+                    tn = rr.autotask_ticket_number.strip()
+                    break
+
+        internal_ticket = _ensure_internal_ticket_for_autotask(
+            ticket_number=tn,
+            job=job,
+            run_ids=[int(x.id) for x in runs_for_ticket if getattr(x, "id", None)],
+            now=now,
+        )
+
+        # If terminal in PSA: resolve internally.
+        if internal_ticket is not None and status_int in AUTOTASK_TERMINAL_STATUS_IDS:
+            _resolve_internal_ticket_for_job(
+                ticket=internal_ticket,
+                job=job,
+                run_ids=[int(x.id) for x in runs_for_ticket if getattr(x, "id", None)],
+                now=now,
+            )
+
+    try:
+        db.session.commit()
+    except Exception:
+        db.session.rollback()
 
 
 def _build_autotask_client_from_settings():
@@ -440,6 +697,15 @@ def run_checks_page():
         # Don't block the page if missed-run generation fails.
         pass
 
+    # Phase 2 (read-only PSA driven): sync internal ticket resolved state based on PSA ticket status.
+    # Best-effort: never blocks page load.
+    try:
+        run_q = JobRun.query.filter(JobRun.reviewed_at.is_(None), JobRun.autotask_ticket_id.isnot(None))
+        run_ids = [int(x) for (x,) in run_q.with_entities(JobRun.id).limit(800).all()]
+        _poll_autotask_ticket_states_for_runs(run_ids=run_ids)
+    except Exception:
+        pass
+
     # Aggregated per-job rows
     base = (
         db.session.query(
@@ -697,11 +963,15 @@ def run_checks_page():
             }
         )
 
+    settings = _get_or_create_settings()
+    autotask_enabled = bool(getattr(settings, "autotask_enabled", False))
+
     return render_template(
         "main/run_checks.html",
         rows=payload,
         is_admin=(get_active_role() == "admin"),
         include_reviewed=include_reviewed,
+        autotask_enabled=autotask_enabled,
     )
 
 
@@ -895,7 +1165,16 @@ def api_run_checks_create_autotask_ticket():
     if not run:
         return jsonify({"status": "error", "message": "Run not found."}), 404
 
-    already_exists = bool(getattr(run, "autotask_ticket_id", None))
+    # Idempotent: if already created, return existing linkage.
+    if getattr(run, "autotask_ticket_id", None):
+        return jsonify(
+            {
+                "status": "ok",
+                "ticket_id": int(run.autotask_ticket_id),
+                "ticket_number": getattr(run, "autotask_ticket_number", None) or "",
+                "already_exists": True,
+            }
+        )
 
     job = Job.query.get(run.job_id)
     if not job:
@@ -994,125 +1273,42 @@ def api_run_checks_create_autotask_ticket():
     if priority_id:
         payload["priority"] = int(priority_id)
 
-    client = None
     try:
         client = _build_autotask_client_from_settings()
+        created = client.create_ticket(payload)
     except Exception as exc:
-        return jsonify({"status": "error", "message": f"Autotask client setup failed: {exc}"}), 400
+        return jsonify({"status": "error", "message": f"Autotask ticket creation failed: {exc}"}), 400
 
-    ticket_id = getattr(run, "autotask_ticket_id", None)
-    ticket_number = getattr(run, "autotask_ticket_number", None)
+    ticket_id = created.get("id") if isinstance(created, dict) else None
+    ticket_number = None
+    if isinstance(created, dict):
+        ticket_number = created.get("ticketNumber") or created.get("number") or created.get("ticket_number")
 
-    # Create ticket only when missing.
     if not ticket_id:
-        try:
-            created = client.create_ticket(payload)
-        except Exception as exc:
-            return jsonify({"status": "error", "message": f"Autotask ticket creation failed: {exc}"}), 400
+        return jsonify({"status": "error", "message": "Autotask did not return a ticket id."}), 400
 
-        ticket_id = created.get("id") if isinstance(created, dict) else None
-        if isinstance(created, dict):
-            ticket_number = created.get("ticketNumber") or created.get("number") or created.get("ticket_number")
-
-        if not ticket_id:
-            return jsonify({"status": "error", "message": "Autotask did not return a ticket id."}), 400
-
-        try:
-            run.autotask_ticket_id = int(ticket_id)
-        except Exception:
-            run.autotask_ticket_id = None
-
-        run.autotask_ticket_number = (str(ticket_number).strip() if ticket_number is not None else "") or None
-        run.autotask_ticket_created_at = datetime.utcnow()
-        run.autotask_ticket_created_by_user_id = current_user.id
-
-        try:
-            db.session.add(run)
-            db.session.commit()
-        except Exception as exc:
-            db.session.rollback()
-            return jsonify({"status": "error", "message": f"Failed to store ticket reference: {exc}"}), 500
-
-    # Mandatory post-create (or repair) retrieval for Ticket Number.
-    if ticket_id and not (ticket_number or "").strip():
-        try:
-            fetched = client.get_ticket(int(ticket_id))
-            ticket_number = None
-            if isinstance(fetched, dict):
-                ticket_number = fetched.get("ticketNumber") or fetched.get("number") or fetched.get("ticket_number")
-            ticket_number = (str(ticket_number).strip() if ticket_number is not None else "") or None
-        except Exception as exc:
-            # Ticket ID is persisted, but internal propagation must not proceed without the ticket number.
-            return jsonify({"status": "error", "message": f"Autotask ticket created but ticket number retrieval failed: {exc}"}), 400
-
-        if not ticket_number:
-            return jsonify({"status": "error", "message": "Autotask ticket created but ticket number is not available."}), 400
-
-        try:
-            run = JobRun.query.get(run_id)
-            if not run:
-                return jsonify({"status": "error", "message": "Run not found."}), 404
-            run.autotask_ticket_number = ticket_number
-            db.session.add(run)
-            db.session.commit()
-        except Exception as exc:
-            db.session.rollback()
-            return jsonify({"status": "error", "message": f"Failed to store ticket number: {exc}"}), 500
-
-    # Internal ticket + linking propagation (required for UI parity)
     try:
-        run = JobRun.query.get(run_id)
-        if not run:
-            return jsonify({"status": "error", "message": "Run not found."}), 404
+        run.autotask_ticket_id = int(ticket_id)
+    except Exception:
+        run.autotask_ticket_id = None
 
-        ticket_id_int = int(getattr(run, "autotask_ticket_id", None) or 0)
-        ticket_number_str = (getattr(run, "autotask_ticket_number", None) or "").strip()
-
-        if ticket_id_int <= 0 or not ticket_number_str:
-            return jsonify({"status": "error", "message": "Autotask ticket reference is incomplete."}), 400
-
-        # Create/reuse internal ticket (code == Autotask Ticket Number)
-        internal_ticket = ensure_internal_ticket_for_job(
-            ticket_code=ticket_number_str,
-            title=subject,
-            description=description,
-            job=job,
-            active_from_dt=getattr(run, "run_at", None) or datetime.utcnow(),
-            start_dt=getattr(run, "autotask_ticket_created_at", None) or datetime.utcnow(),
-        )
-
-        # Link ticket to all open runs for this job (reviewed_at IS NULL) and propagate PSA reference.
-        open_runs = JobRun.query.filter(JobRun.job_id == job.id, JobRun.reviewed_at.is_(None)).all()
-        run_ids_to_link: list[int] = []
-
-        for r in open_runs:
-            # Never overwrite an existing different Autotask ticket for a run.
-            existing_id = getattr(r, "autotask_ticket_id", None)
-            if existing_id and int(existing_id) != ticket_id_int:
-                continue
-
-            if not existing_id:
-                r.autotask_ticket_id = ticket_id_int
-                r.autotask_ticket_number = ticket_number_str
-                r.autotask_ticket_created_at = getattr(run, "autotask_ticket_created_at", None)
-                r.autotask_ticket_created_by_user_id = getattr(run, "autotask_ticket_created_by_user_id", None)
-                db.session.add(r)
-
-            run_ids_to_link.append(int(r.id))
-
-        ensure_ticket_jobrun_links(ticket_id=int(internal_ticket.id), run_ids=run_ids_to_link, link_source="autotask")
+    run.autotask_ticket_number = (str(ticket_number).strip() if ticket_number is not None else "") or None
+    run.autotask_ticket_created_at = datetime.utcnow()
+    run.autotask_ticket_created_by_user_id = current_user.id
 
+    try:
+        db.session.add(run)
         db.session.commit()
     except Exception as exc:
         db.session.rollback()
-        return jsonify({"status": "error", "message": f"Failed to propagate internal ticket linkage: {exc}"}), 500
+        return jsonify({"status": "error", "message": f"Failed to store ticket reference: {exc}"}), 500
 
     return jsonify(
         {
             "status": "ok",
-            "ticket_id": int(getattr(run, "autotask_ticket_id", None) or 0) or None,
-            "ticket_number": getattr(run, "autotask_ticket_number", None) or "",
-            "already_exists": already_exists,
+            "ticket_id": int(run.autotask_ticket_id) if run.autotask_ticket_id else None,
+            "ticket_number": run.autotask_ticket_number or "",
+            "already_exists": False,
         }
     )
 
diff --git a/docs/changelog.md b/docs/changelog.md
index 4e24a7e..8c824a8 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -279,6 +279,17 @@ Changes:
 - Ensured consistent use of renderRun() when toggling the Autotask integration on and off.
 - Prevented UI errors when re-enabling the Autotask integration after it was disabled.
 
+## v20260119-03-autotask-ticket-state-sync
+
+### Changes:
+- Implemented Phase 2: read-only PSA-driven ticket state synchronisation.
+- Added targeted polling on Run Checks load for runs with an Autotask Ticket ID and no reviewed_at timestamp.
+- Introduced authoritative fallback logic using GET Tickets/{TicketID} when tickets are missing from active list queries.
+- Mapped Autotask status ID 5 (Completed) to automatic resolution of all linked active runs.
+- Marked resolved runs explicitly as "Resolved by PSA" without modifying Autotask data.
+- Ensured multi-run consistency: one Autotask ticket correctly resolves all associated active job runs.
+- Preserved internal Ticket and TicketJobRun integrity to maintain legacy Tickets, Remarks, and Job Details behaviour.
+
 ***
 
 ## v0.1.21

From 0cabd2e0fcbf9e2c3dbb250018231192e143291b Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Mon, 19 Jan 2026 15:10:00 +0100
Subject: [PATCH 46/63] Auto-commit local changes before build (2026-01-19
 15:10:00)

---
 .last-branch                                  |  2 +-
 .../src/backend/app/main/routes_api.py        |  4 +
 .../src/backend/app/main/routes_run_checks.py | 55 +++++++++++-
 .../src/backend/app/migrations.py             | 28 ++++++
 .../backupchecks/src/backend/app/models.py    |  2 +
 .../src/templates/main/run_checks.html        | 90 ++++++++++++++++++-
 docs/changelog.md                             | 10 +++
 7 files changed, 184 insertions(+), 7 deletions(-)

diff --git a/.last-branch b/.last-branch
index ded7de3..cfed06c 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260119-12-autotask-ticket-state-sync
+v20260119-13-autotask-psa-resolved-recreate
diff --git a/containers/backupchecks/src/backend/app/main/routes_api.py b/containers/backupchecks/src/backend/app/main/routes_api.py
index 0da7b4f..395968a 100644
--- a/containers/backupchecks/src/backend/app/main/routes_api.py
+++ b/containers/backupchecks/src/backend/app/main/routes_api.py
@@ -347,6 +347,8 @@ def api_ticket_resolve(ticket_id: int):
             open_scope = TicketScope.query.filter_by(ticket_id=ticket.id, resolved_at=None).first()
             if open_scope is None and ticket.resolved_at is None:
                 ticket.resolved_at = now
+                if getattr(ticket, "resolved_origin", None) is None:
+                    ticket.resolved_origin = "backupchecks"
 
             db.session.commit()
         except Exception as exc:
@@ -358,6 +360,8 @@ def api_ticket_resolve(ticket_id: int):
     # Global resolve (from central ticket list): resolve ticket and all scopes
     if ticket.resolved_at is None:
         ticket.resolved_at = now
+        if getattr(ticket, "resolved_origin", None) is None:
+            ticket.resolved_origin = "backupchecks"
 
     try:
         # Resolve any still-open scopes
diff --git a/containers/backupchecks/src/backend/app/main/routes_run_checks.py b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
index bb07517..9e67216 100644
--- a/containers/backupchecks/src/backend/app/main/routes_run_checks.py
+++ b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
@@ -111,6 +111,8 @@ def _resolve_internal_ticket_for_job(
 
     if ticket.resolved_at is None:
         ticket.resolved_at = now
+        if getattr(ticket, "resolved_origin", None) is None:
+            ticket.resolved_origin = "psa"
 
     # Resolve all still-open scopes.
     try:
@@ -999,6 +1001,20 @@ def run_checks_details():
 
     runs = q.order_by(func.coalesce(JobRun.run_at, JobRun.created_at).desc(), JobRun.id.desc()).limit(400).all()
 
+    # Prefetch internal ticket resolution info for Autotask-linked runs (Phase 2 UI).
+    autotask_codes = set()
+    for _r in runs:
+        code = (getattr(_r, "autotask_ticket_number", None) or "").strip()
+        if code:
+            autotask_codes.add(code)
+    ticket_by_code = {}
+    if autotask_codes:
+        try:
+            for _t in Ticket.query.filter(Ticket.ticket_code.in_(list(autotask_codes))).all():
+                ticket_by_code[_t.ticket_code] = _t
+        except Exception:
+            ticket_by_code = {}
+
     runs_payload = []
     for run in runs:
         msg = MailMessage.query.get(run.mail_message_id) if run.mail_message_id else None
@@ -1104,6 +1120,20 @@ def run_checks_details():
             except Exception:
                 pass
 
+        # Autotask ticket resolution info (derived from internal Ticket)
+        at_resolved = False
+        at_resolved_origin = ""
+        at_resolved_at = ""
+        try:
+            _code = (getattr(run, "autotask_ticket_number", None) or "").strip()
+            if _code and _code in ticket_by_code:
+                _t = ticket_by_code[_code]
+                at_resolved = getattr(_t, "resolved_at", None) is not None
+                at_resolved_origin = (getattr(_t, "resolved_origin", None) or "")
+                at_resolved_at = _format_datetime(getattr(_t, "resolved_at", None)) if getattr(_t, "resolved_at", None) else ""
+        except Exception:
+            pass
+
         status_display = run.status or "-"
         try:
             status_display, _, _, _ov_id, _ov_reason = _apply_overrides_to_run(job, run)
@@ -1127,6 +1157,9 @@ def run_checks_details():
                 "objects": objects_payload,
                 "autotask_ticket_id": getattr(run, "autotask_ticket_id", None),
                 "autotask_ticket_number": getattr(run, "autotask_ticket_number", None) or "",
+                "autotask_ticket_is_resolved": bool(at_resolved),
+                "autotask_ticket_resolved_origin": at_resolved_origin,
+                "autotask_ticket_resolved_at": at_resolved_at,
             }
         )
 
@@ -1165,9 +1198,27 @@ def api_run_checks_create_autotask_ticket():
     if not run:
         return jsonify({"status": "error", "message": "Run not found."}), 404
 
-    # Idempotent: if already created, return existing linkage.
+    # If a ticket is already linked we normally prevent duplicate creation.
+    # Exception: if the linked ticket is resolved (e.g. resolved by PSA), allow creating a new ticket.
     if getattr(run, "autotask_ticket_id", None):
-        return jsonify(
+        already_resolved = False
+        try:
+            code = (getattr(run, "autotask_ticket_number", None) or "").strip()
+            if code:
+                t = Ticket.query.filter_by(ticket_code=code).first()
+                already_resolved = bool(getattr(t, "resolved_at", None)) if t else False
+        except Exception:
+            already_resolved = False
+        if not already_resolved:
+            return jsonify(
+                {
+                    "status": "ok",
+                    "ticket_id": int(run.autotask_ticket_id),
+                    "ticket_number": getattr(run, "autotask_ticket_number", None) or "",
+                    "already_exists": True,
+                }
+            )
+        # resolved -> continue, create a new Autotask ticket and overwrite current linkage.
             {
                 "status": "ok",
                 "ticket_id": int(run.autotask_ticket_id),
diff --git a/containers/backupchecks/src/backend/app/migrations.py b/containers/backupchecks/src/backend/app/migrations.py
index b1d1405..69fa355 100644
--- a/containers/backupchecks/src/backend/app/migrations.py
+++ b/containers/backupchecks/src/backend/app/migrations.py
@@ -894,6 +894,7 @@ def run_migrations() -> None:
     migrate_feedback_tables()
     migrate_feedback_replies_table()
     migrate_tickets_active_from_date()
+    migrate_tickets_resolved_origin()
     migrate_remarks_active_from_date()
     migrate_overrides_match_columns()
     migrate_job_runs_review_tracking()
@@ -1253,6 +1254,33 @@ def migrate_tickets_active_from_date() -> None:
 
 
 
+
+def migrate_tickets_resolved_origin() -> None:
+    """Add tickets.resolved_origin column if missing.
+
+    Used to show whether a ticket was resolved by PSA polling or manually inside Backupchecks.
+    """
+
+    table = "tickets"
+    try:
+        engine = db.get_engine()
+    except Exception as exc:
+        print(f"[migrations] Could not get engine for tickets resolved_origin migration: {exc}")
+        return
+
+    try:
+        with engine.connect() as conn:
+            cols = _get_table_columns(conn, table)
+            if not cols:
+                return
+            if "resolved_origin" not in cols:
+                print("[migrations] Adding tickets.resolved_origin column...")
+                conn.execute(text('ALTER TABLE "tickets" ADD COLUMN resolved_origin VARCHAR(32)'))
+    except Exception as exc:
+        print(f"[migrations] tickets resolved_origin migration failed (continuing): {exc}")
+
+    print("[migrations] migrate_tickets_resolved_origin completed.")
+
 def migrate_mail_messages_overall_message() -> None:
     """Add overall_message column to mail_messages if missing."""
     table = "mail_messages"
diff --git a/containers/backupchecks/src/backend/app/models.py b/containers/backupchecks/src/backend/app/models.py
index 4ecba7d..b799cc4 100644
--- a/containers/backupchecks/src/backend/app/models.py
+++ b/containers/backupchecks/src/backend/app/models.py
@@ -421,6 +421,8 @@ class Ticket(db.Model):
     # Audit timestamp: when the ticket was created (UTC, naive)
     start_date = db.Column(db.DateTime, nullable=False)
     resolved_at = db.Column(db.DateTime)
+    # Resolution origin for audit/UI: psa | backupchecks
+    resolved_origin = db.Column(db.String(32))
     created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
     updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False)
 
diff --git a/containers/backupchecks/src/templates/main/run_checks.html b/containers/backupchecks/src/templates/main/run_checks.html
index dcf56ca..b06bd5b 100644
--- a/containers/backupchecks/src/templates/main/run_checks.html
+++ b/containers/backupchecks/src/templates/main/run_checks.html
@@ -216,12 +216,21 @@
                     <div class="row g-2 align-items-start">
 	                      <div class="col-12 col-lg-6">
 	                        <div class="border rounded p-2">
+	                          {% if autotask_enabled %}
 	                          <div class="d-flex align-items-center justify-content-between">
 	                            <div class="fw-semibold">Autotask ticket</div>
 	                            <button type="button" class="btn btn-sm btn-outline-primary" id="rcm_autotask_create">Create</button>
 	                          </div>
 	                          <div class="mt-2 small" id="rcm_autotask_info"></div>
 	                          <div class="mt-2 small text-muted" id="rcm_autotask_status"></div>
+	                          {% else %}
+	                          <div class="fw-semibold">New ticket</div>
+	                          <div class="d-flex gap-2 mt-1">
+	                            <input class="form-control form-control-sm" id="rcm_ticket_code" type="text" placeholder="Ticket number (e.g., T20260106.0001)" />
+	                            <button type="button" class="btn btn-sm btn-outline-primary" id="rcm_ticket_save">Add</button>
+	                          </div>
+	                          <div class="mt-1 small text-muted" id="rcm_ticket_status"></div>
+	                          {% endif %}
 	                        </div>
 	                      </div>
                       <div class="col-12 col-lg-6">
@@ -297,6 +306,8 @@
     var currentRunId = null;
     var currentPayload = null;
 
+    var autotaskEnabled = {{ 'true' if autotask_enabled else 'false' }};
+
     var btnMarkAllReviewed = document.getElementById('rcm_mark_all_reviewed');
     var btnMarkSuccessOverride = document.getElementById('rcm_mark_success_override');
 
@@ -843,17 +854,24 @@ table.addEventListener('change', function (e) {
       var atInfo = document.getElementById('rcm_autotask_info');
       var atStatus = document.getElementById('rcm_autotask_status');
 
+      var btnTicket = document.getElementById('rcm_ticket_save');
+      var tCode = document.getElementById('rcm_ticket_code');
+      var tStatus = document.getElementById('rcm_ticket_status');
+
       var btnRemark = document.getElementById('rcm_remark_save');
       var rBody = document.getElementById('rcm_remark_body');
       var rStatus = document.getElementById('rcm_remark_status');
 
       function clearStatus() {
         if (atStatus) atStatus.textContent = '';
+        if (tStatus) tStatus.textContent = '';
         if (rStatus) rStatus.textContent = '';
       }
 
       function setDisabled(disabled) {
         if (btnAutotask) btnAutotask.disabled = disabled;
+        if (btnTicket) btnTicket.disabled = disabled;
+        if (tCode) tCode.disabled = disabled;
         if (btnRemark) btnRemark.disabled = disabled;
         if (rBody) rBody.disabled = disabled;
       }
@@ -864,16 +882,72 @@ table.addEventListener('change', function (e) {
       function renderAutotaskInfo(run) {
         if (!atInfo) return;
         var num = (run && run.autotask_ticket_number) ? String(run.autotask_ticket_number) : '';
+        var isResolved = !!(run && run.autotask_ticket_is_resolved);
+        var origin = (run && run.autotask_ticket_resolved_origin) ? String(run.autotask_ticket_resolved_origin) : '';
+
         if (num) {
-          atInfo.innerHTML = '<div><strong>Ticket:</strong> ' + escapeHtml(num) + '</div>';
+          var extra = '';
+          if (isResolved && origin === 'psa') {
+            extra = '<div class="mt-1"><span class="badge bg-secondary">Resolved by PSA</span></div>';
+          }
+          atInfo.innerHTML = '<div><strong>Ticket:</strong> ' + escapeHtml(num) + '</div>' + extra;
         } else if (run && run.autotask_ticket_id) {
           atInfo.innerHTML = '<div><strong>Ticket:</strong> created</div>';
         } else {
           atInfo.innerHTML = '<div class="text-muted">No Autotask ticket created for this run.</div>';
         }
+
+        if (btnAutotask) {
+          if (run && run.autotask_ticket_id && isResolved) btnAutotask.textContent = 'Create new';
+          else btnAutotask.textContent = 'Create';
+        }
       }
       window.__rcmRenderAutotaskInfo = renderAutotaskInfo;
 
+      window.__rcmSetAutotaskCreateLabel = function (run) {
+        if (!btnAutotask) return;
+        var hasTicket = !!(run && run.autotask_ticket_id);
+        var isResolved = !!(run && run.autotask_ticket_is_resolved);
+        btnAutotask.textContent = (hasTicket && isResolved) ? 'Create new' : 'Create';
+      };
+
+
+      function isValidTicketCode(code) {
+        return /^T\d{8}\.\d{4}$/.test(code);
+      }
+
+      if (btnTicket) {
+        btnTicket.addEventListener('click', function () {
+          if (!currentRunId) { alert('Select a run first.'); return; }
+          clearStatus();
+          var ticket_code = tCode ? (tCode.value || '').trim().toUpperCase() : '';
+          if (!ticket_code) {
+            if (tStatus) tStatus.textContent = 'Ticket number is required.';
+            else alert('Ticket number is required.');
+            return;
+          }
+          if (!isValidTicketCode(ticket_code)) {
+            if (tStatus) tStatus.textContent = 'Invalid ticket number format. Expected TYYYYMMDD.####.';
+            else alert('Invalid ticket number format. Expected TYYYYMMDD.####.');
+            return;
+          }
+          if (tStatus) tStatus.textContent = 'Saving...';
+          apiJson('/api/tickets', {
+            method: 'POST',
+            body: JSON.stringify({job_run_id: currentRunId, ticket_code: ticket_code})
+          })
+          .then(function () {
+            if (tCode) tCode.value = '';
+            if (tStatus) tStatus.textContent = '';
+            loadAlerts(currentRunId);
+          })
+          .catch(function (e) {
+            if (tStatus) tStatus.textContent = e.message || 'Failed.';
+            else alert(e.message || 'Failed.');
+          });
+        });
+      }
+
       if (btnAutotask) {
         btnAutotask.addEventListener('click', function () {
           if (!currentRunId) { alert('Select a run first.'); return; }
@@ -901,7 +975,7 @@ table.addEventListener('change', function (e) {
                   for (var i = 0; i < runs.length; i++) {
                     if (String(runs[i].id) === String(keepRunId)) { idx = i; break; }
                   }
-                  renderRun(payload, idx);
+                  renderModal(payload, idx);
                 });
             }
           })
@@ -910,7 +984,7 @@ table.addEventListener('change', function (e) {
             else alert(e.message || 'Failed.');
           })
           .finally(function () {
-            // State will be recalculated by renderRun.
+            // State will be recalculated by renderModal/renderRun.
           });
         });
       }
@@ -977,7 +1051,15 @@ table.addEventListener('change', function (e) {
       currentRunId = run.id || null;
       if (window.__rcmClearCreateStatus) window.__rcmClearCreateStatus();
       if (window.__rcmRenderAutotaskInfo) window.__rcmRenderAutotaskInfo(run);
-      if (window.__rcmSetCreateDisabled) window.__rcmSetCreateDisabled(!currentRunId || !!run.autotask_ticket_id);
+      if (window.__rcmSetAutotaskCreateLabel) window.__rcmSetAutotaskCreateLabel(run);
+      if (window.__rcmSetCreateDisabled) {
+        if (autotaskEnabled) {
+          var canCreateAt = !!currentRunId && (!run.autotask_ticket_id || !!run.autotask_ticket_is_resolved);
+          window.__rcmSetCreateDisabled(!canCreateAt);
+        } else {
+          window.__rcmSetCreateDisabled(!currentRunId);
+        }
+      }
       if (btnMarkSuccessOverride) {
         var _rs = (run.status || '').toString().toLowerCase();
         var _canOverride = !!currentRunId && !run.missed && (_rs.indexOf('override') === -1) && (_rs.indexOf('success') === -1);
diff --git a/docs/changelog.md b/docs/changelog.md
index 8c824a8..fd4a731 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -290,6 +290,16 @@ Changes:
 - Ensured multi-run consistency: one Autotask ticket correctly resolves all associated active job runs.
 - Preserved internal Ticket and TicketJobRun integrity to maintain legacy Tickets, Remarks, and Job Details behaviour.
 
+## v20260119-04-autotask-psa-resolved-ui-recreate-ticket
+
+### Changes:
+- Added explicit UI indication when an Autotask ticket is resolved by PSA ("Resolved by PSA (Autotask)").
+- Differentiated resolution origin between PSA-driven resolution and Backupchecks-driven resolution.
+- Re-enabled ticket creation when an existing Autotask ticket was resolved by PSA, allowing operators to create a new ticket if the previous one was closed incorrectly.
+- Updated Autotask ticket panel to reflect resolved state without blocking further actions.
+- Extended backend validation to allow ticket re-creation after PSA-resolved tickets while preserving historical ticket links.
+- Ensured legacy Tickets, Remarks, and Job Details behaviour remains intact.
+
 ***
 
 ## v0.1.21

From 8407bf45abb5220318e011f056fdb2019ff4275d Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Mon, 19 Jan 2026 15:30:36 +0100
Subject: [PATCH 47/63] Auto-commit local changes before build (2026-01-19
 15:30:36)

---
 .last-branch                                              | 2 +-
 .../src/backend/app/main/routes_run_checks.py             | 7 -------
 docs/changelog.md                                         | 8 ++++++++
 3 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/.last-branch b/.last-branch
index cfed06c..f37801d 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260119-13-autotask-psa-resolved-recreate
+v20260119-14-fix-routes-runchecks-syntax
diff --git a/containers/backupchecks/src/backend/app/main/routes_run_checks.py b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
index 9e67216..0a81bb3 100644
--- a/containers/backupchecks/src/backend/app/main/routes_run_checks.py
+++ b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
@@ -1219,13 +1219,6 @@ def api_run_checks_create_autotask_ticket():
                 }
             )
         # resolved -> continue, create a new Autotask ticket and overwrite current linkage.
-            {
-                "status": "ok",
-                "ticket_id": int(run.autotask_ticket_id),
-                "ticket_number": getattr(run, "autotask_ticket_number", None) or "",
-                "already_exists": True,
-            }
-        )
 
     job = Job.query.get(run.job_id)
     if not job:
diff --git a/docs/changelog.md b/docs/changelog.md
index fd4a731..ff1a1da 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -300,6 +300,14 @@ Changes:
 - Extended backend validation to allow ticket re-creation after PSA-resolved tickets while preserving historical ticket links.
 - Ensured legacy Tickets, Remarks, and Job Details behaviour remains intact.
 
+## v20260119-14-fix-routes-runchecks-syntax
+
+### Changes:
+- Fixed a Python SyntaxError in routes_run_checks.py caused by an unmatched closing parenthesis.
+- Removed an extra closing bracket introduced during the Autotask PSA resolved / recreate ticket changes.
+- Restored successful Gunicorn worker startup and backend application boot.
+- No functional or behavioural changes beyond resolving the syntax error.
+
 ***
 
 ## v0.1.21

From a7a61fdd64875b4a4fd870daa2a821b9da55e946 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Mon, 19 Jan 2026 15:40:00 +0100
Subject: [PATCH 48/63] Auto-commit local changes before build (2026-01-19
 15:40:00)

---
 .last-branch                                  |  2 +-
 .../src/backend/app/migrations.py             | 34 ++++++++++++++++---
 2 files changed, 31 insertions(+), 5 deletions(-)

diff --git a/.last-branch b/.last-branch
index f37801d..71635d1 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260119-14-fix-routes-runchecks-syntax
+v20260119-15-fix-migrations-autotask-phase2
diff --git a/containers/backupchecks/src/backend/app/migrations.py b/containers/backupchecks/src/backend/app/migrations.py
index 69fa355..8dfca71 100644
--- a/containers/backupchecks/src/backend/app/migrations.py
+++ b/containers/backupchecks/src/backend/app/migrations.py
@@ -43,6 +43,30 @@ def _column_exists_on_conn(conn, table_name: str, column_name: str) -> bool:
     return result.first() is not None
 
 
+def _get_table_columns(conn, table_name: str) -> set[str]:
+    """Return a set of column names for the given table using the provided connection.
+
+    This helper is designed for use inside engine.begin() blocks so that any
+    errors are properly rolled back before the connection is returned to the pool.
+
+    If the table does not exist (or cannot be inspected), an empty set is returned.
+    """
+    try:
+        result = conn.execute(
+            text(
+                """
+                SELECT column_name
+                FROM information_schema.columns
+                WHERE table_name = :table
+                """
+            ),
+            {"table": table_name},
+        )
+        return {row[0] for row in result.fetchall()}
+    except Exception:
+        return set()
+
+
 def migrate_add_username_to_users() -> None:
     """Ensure users.username column exists and is NOT NULL and UNIQUE.
 
@@ -925,9 +949,10 @@ def migrate_job_runs_autotask_ticket_fields() -> None:
         return
 
     try:
-        with engine.connect() as conn:
+        with engine.begin() as conn:
             cols = _get_table_columns(conn, table)
             if not cols:
+                print("[migrations] job_runs table not found; skipping migrate_job_runs_autotask_ticket_fields.")
                 return
 
             if "autotask_ticket_id" not in cols:
@@ -957,12 +982,12 @@ def migrate_job_runs_autotask_ticket_fields() -> None:
                     )
                 except Exception as exc:
                     print(
-                        f"[migrations] Could not add FK job_runs.autotask_ticket_created_by_user_id -> users.id (continuing): {exc}"
+                        f"[migrations] Could not add FK job_runs_autotask_ticket_created_by_user_id -> users.id (continuing): {exc}"
                     )
 
             conn.execute(text('CREATE INDEX IF NOT EXISTS idx_job_runs_autotask_ticket_id ON "job_runs" (autotask_ticket_id)'))
     except Exception as exc:
-        print(f"[migrations] job_runs table not found; skipping migrate_job_runs_autotask_ticket_fields: {exc}")
+        print(f"[migrations] migrate_job_runs_autotask_ticket_fields failed (continuing): {exc}")
         return
 
     print("[migrations] migrate_job_runs_autotask_ticket_fields completed.")
@@ -1269,9 +1294,10 @@ def migrate_tickets_resolved_origin() -> None:
         return
 
     try:
-        with engine.connect() as conn:
+        with engine.begin() as conn:
             cols = _get_table_columns(conn, table)
             if not cols:
+                print("[migrations] tickets table not found; skipping migrate_tickets_resolved_origin.")
                 return
             if "resolved_origin" not in cols:
                 print("[migrations] Adding tickets.resolved_origin column...")

From 4b3b6162a006a8f8b0d62b0662887f9d9a571074 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Mon, 19 Jan 2026 15:47:15 +0100
Subject: [PATCH 49/63] Auto-commit local changes before build (2026-01-19
 15:47:15)

---
 .last-branch                                     |  2 +-
 .../src/templates/main/run_checks.html           |  4 ++--
 docs/changelog.md                                | 16 ++++++++++++++++
 3 files changed, 19 insertions(+), 3 deletions(-)

diff --git a/.last-branch b/.last-branch
index 71635d1..db1f226 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260119-15-fix-migrations-autotask-phase2
+v20260119-16-fix-runchecks-render-modal
diff --git a/containers/backupchecks/src/templates/main/run_checks.html b/containers/backupchecks/src/templates/main/run_checks.html
index b06bd5b..93c94ba 100644
--- a/containers/backupchecks/src/templates/main/run_checks.html
+++ b/containers/backupchecks/src/templates/main/run_checks.html
@@ -975,7 +975,7 @@ table.addEventListener('change', function (e) {
                   for (var i = 0; i < runs.length; i++) {
                     if (String(runs[i].id) === String(keepRunId)) { idx = i; break; }
                   }
-                  renderModal(payload, idx);
+                  renderRun(payload, idx);
                 });
             }
           })
@@ -984,7 +984,7 @@ table.addEventListener('change', function (e) {
             else alert(e.message || 'Failed.');
           })
           .finally(function () {
-            // State will be recalculated by renderModal/renderRun.
+            // State will be recalculated by renderRun.
           });
         });
       }
diff --git a/docs/changelog.md b/docs/changelog.md
index ff1a1da..b714e9c 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -308,6 +308,22 @@ Changes:
 - Restored successful Gunicorn worker startup and backend application boot.
 - No functional or behavioural changes beyond resolving the syntax error.
 
+## v20260119-15-fix-migrations-autotask-phase2
+
+### Changes:
+- Restored the missing `_get_table_columns()` helper function required by multiple database migrations.
+- Fixed Autotask-related migrations that introduced the `resolved_origin` and Autotask job_run fields.
+- Ensured all migrations run inside a safe transaction context so failures always trigger a rollback.
+- Prevented database sessions from remaining in an aborted state after a failed migration.
+- Resolved runtime database errors on the Run Checks page caused by earlier migration failures.
+
+## v20260119-16-fix-runchecks-render-modal
+
+### Changes:
+- Fixed a JavaScript runtime error on the Run Checks page where `renderModal` was referenced but not defined.
+- Replaced the obsolete `renderModal(...)` call with the correct Run Checks rendering function.
+- Restored proper Run Checks page rendering without breaking existing ticket or modal behaviour.
+
 ***
 
 ## v0.1.21

From b56cdacf6b12e10841e9c0bfd05906f503891e5f Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Mon, 19 Jan 2026 15:59:26 +0100
Subject: [PATCH 50/63] Auto-commit local changes before build (2026-01-19
 15:59:26)

---
 .last-branch                                  |  2 +-
 .../src/backend/app/main/routes_run_checks.py | 51 ++++++++++++++++++-
 2 files changed, 50 insertions(+), 3 deletions(-)

diff --git a/.last-branch b/.last-branch
index db1f226..6ee1479 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260119-16-fix-runchecks-render-modal
+v20260119-17-fix-autotask-postcreate-ticketnumber-internal-linking
diff --git a/containers/backupchecks/src/backend/app/main/routes_run_checks.py b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
index 0a81bb3..ab23fb2 100644
--- a/containers/backupchecks/src/backend/app/main/routes_run_checks.py
+++ b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
@@ -1331,15 +1331,50 @@ def api_run_checks_create_autotask_ticket():
     if not ticket_id:
         return jsonify({"status": "error", "message": "Autotask did not return a ticket id."}), 400
 
+    # Mandatory post-create retrieval: create response does not reliably include Ticket Number.
+    ticket_number_str = (str(ticket_number).strip() if ticket_number is not None else "").strip()
+    try:
+        if not ticket_number_str:
+            fetched = client.get_ticket(int(ticket_id))
+            if isinstance(fetched, dict):
+                ticket_number_str = (
+                    str(fetched.get("ticketNumber") or fetched.get("number") or fetched.get("ticket_number") or "").strip()
+                )
+    except Exception:
+        ticket_number_str = ticket_number_str
+
+    now = datetime.utcnow()
+
     try:
         run.autotask_ticket_id = int(ticket_id)
     except Exception:
         run.autotask_ticket_id = None
 
-    run.autotask_ticket_number = (str(ticket_number).strip() if ticket_number is not None else "") or None
-    run.autotask_ticket_created_at = datetime.utcnow()
+    run.autotask_ticket_number = (ticket_number_str or "") or None
+    run.autotask_ticket_created_at = now
     run.autotask_ticket_created_by_user_id = current_user.id
 
+    # Propagate linkage to all active (unreviewed) runs of the same job.
+    active_runs: list[JobRun] = []
+    try:
+        active_runs = JobRun.query.filter(JobRun.job_id == job.id, JobRun.reviewed_at.is_(None)).all()
+    except Exception:
+        active_runs = [run]
+
+    run_ids: list[int] = []
+    for rr in active_runs or []:
+        if getattr(rr, "id", None):
+            run_ids.append(int(rr.id))
+        if getattr(rr, "autotask_ticket_id", None) is None:
+            rr.autotask_ticket_id = int(ticket_id)
+        if ticket_number_str and not (getattr(rr, "autotask_ticket_number", None) or "").strip():
+            rr.autotask_ticket_number = ticket_number_str
+        db.session.add(rr)
+
+    # Create/repair internal Ticket + TicketJobRun links (legacy UI compatibility).
+    if ticket_number_str:
+        _ensure_internal_ticket_for_autotask(ticket_number=ticket_number_str, job=job, run_ids=run_ids, now=now)
+
     try:
         db.session.add(run)
         db.session.commit()
@@ -1347,6 +1382,18 @@ def api_run_checks_create_autotask_ticket():
         db.session.rollback()
         return jsonify({"status": "error", "message": f"Failed to store ticket reference: {exc}"}), 500
 
+    # If Ticket Number is still unknown, surface that explicitly (ticket id is still stored).
+    if not (run.autotask_ticket_number or "").strip():
+        return jsonify(
+            {
+                "status": "ok",
+                "ticket_id": int(run.autotask_ticket_id) if run.autotask_ticket_id else None,
+                "ticket_number": "",
+                "already_exists": False,
+                "warning": "Ticket created, but ticket number could not be retrieved.",
+            }
+        )
+
     return jsonify(
         {
             "status": "ok",

From 63526be59278e707178c03b111c78ca3786bc64f Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Mon, 19 Jan 2026 16:27:38 +0100
Subject: [PATCH 51/63] Auto-commit local changes before build (2026-01-19
 16:27:38)

---
 .last-branch                                  |  2 +-
 .../src/backend/app/main/routes_run_checks.py | 26 ++++++++++++++++---
 docs/changelog.md                             | 17 ++++++++++++
 3 files changed, 40 insertions(+), 5 deletions(-)

diff --git a/.last-branch b/.last-branch
index 6ee1479..df72be1 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260119-17-fix-autotask-postcreate-ticketnumber-internal-linking
+v20260119-18-fix-legacy-ticketnumber-sync
diff --git a/containers/backupchecks/src/backend/app/main/routes_run_checks.py b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
index ab23fb2..75f8a90 100644
--- a/containers/backupchecks/src/backend/app/main/routes_run_checks.py
+++ b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
@@ -49,6 +49,7 @@ def _ensure_internal_ticket_for_autotask(
     job: Job | None,
     run_ids: list[int],
     now: datetime,
+    active_from_dt: datetime | None,
 ) -> Ticket | None:
     """Best-effort: ensure an internal Ticket exists and is linked to the provided runs."""
 
@@ -59,8 +60,10 @@ def _ensure_internal_ticket_for_autotask(
     ticket = Ticket.query.filter(Ticket.ticket_code == code).first()
 
     if ticket is None:
-        # Align with manual ticket creation: active_from_date is today (Amsterdam date).
-        active_from = _to_amsterdam_date(now) or now.date()
+        # Align with manual ticket creation: active_from_date must be <= the run date
+        # so legacy ticket visibility works for historical runs.
+        base_dt = active_from_dt or now
+        active_from = _to_amsterdam_date(base_dt) or base_dt.date()
         ticket = Ticket(
             ticket_code=code,
             description="",
@@ -229,12 +232,19 @@ def _poll_autotask_ticket_states_for_runs(*, run_ids: list[int]) -> None:
                         break
 
             job = Job.query.get(runs_for_ticket[0].job_id) if runs_for_ticket else None
+            active_from_dt = None
+            try:
+                dts = [getattr(x, 'run_at', None) for x in runs_for_ticket if getattr(x, 'run_at', None)]
+                active_from_dt = min(dts) if dts else None
+            except Exception:
+                active_from_dt = None
             _ensure_internal_ticket_for_autotask(
                 ticket_number=tn,
                 job=job,
                 run_ids=[int(x.id) for x in runs_for_ticket if getattr(x, "id", None)],
                 now=now,
-            )
+                active_from_dt=active_from_dt,
+        )
     except Exception:
         # Continue to missing-id fallback.
         pass
@@ -268,6 +278,13 @@ def _poll_autotask_ticket_states_for_runs(*, run_ids: list[int]) -> None:
 
         job = Job.query.get(runs_for_ticket[0].job_id) if runs_for_ticket else None
 
+        active_from_dt = None
+        try:
+            dts = [getattr(x, 'run_at', None) for x in runs_for_ticket if getattr(x, 'run_at', None)]
+            active_from_dt = min(dts) if dts else None
+        except Exception:
+            active_from_dt = None
+
         tn = (str(ticket_number).strip() if ticket_number else "")
         if not tn:
             for rr in runs_for_ticket:
@@ -280,6 +297,7 @@ def _poll_autotask_ticket_states_for_runs(*, run_ids: list[int]) -> None:
             job=job,
             run_ids=[int(x.id) for x in runs_for_ticket if getattr(x, "id", None)],
             now=now,
+            active_from_dt=active_from_dt,
         )
 
         # If terminal in PSA: resolve internally.
@@ -1373,7 +1391,7 @@ def api_run_checks_create_autotask_ticket():
 
     # Create/repair internal Ticket + TicketJobRun links (legacy UI compatibility).
     if ticket_number_str:
-        _ensure_internal_ticket_for_autotask(ticket_number=ticket_number_str, job=job, run_ids=run_ids, now=now)
+        _ensure_internal_ticket_for_autotask(ticket_number=ticket_number_str, job=job, run_ids=run_ids, now=now, active_from_dt=getattr(run, 'run_at', None) or now)
 
     try:
         db.session.add(run)
diff --git a/docs/changelog.md b/docs/changelog.md
index b714e9c..4ec86da 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -324,6 +324,23 @@ Changes:
 - Replaced the obsolete `renderModal(...)` call with the correct Run Checks rendering function.
 - Restored proper Run Checks page rendering without breaking existing ticket or modal behaviour.
 
+## v20260119-17-fix-autotask-postcreate-ticketnumber-internal-linking
+
+### Changes:
+- Enforced mandatory post-create retrieval (GET Tickets/{TicketID}) after Autotask ticket creation to reliably obtain the Ticket Number.
+- Persisted the retrieved Ticket Number to all active (unreviewed) runs of the same job when missing.
+- Restored automatic creation and repair of internal Ticket records once the Ticket Number is known.
+- Restored TicketJobRun linking so Autotask-created tickets appear correctly in Tickets, Remarks, and Job Details.
+- Prevented UI state where a ticket was shown as “created” without a Ticket Number or internal ticket linkage.
+
+## v20260119-18-fix-legacy-ticketnumber-sync
+
+### Changes:
+- Restored legacy ticket number compatibility by aligning internal Ticket activation timing with the original run date.
+- Set internal Ticket `active_from_date` based on the earliest associated run timestamp instead of the current date.
+- Ensured legacy ticket visibility and numbering work correctly for historical runs across Tickets, Remarks, Job Details, and Run Checks indicators.
+- Applied the same logic during post-create processing and Phase 2 polling repair to keep legacy behaviour consistent and idempotent.
+
 ***
 
 ## v0.1.21

From 5131d24751138225b5b4dd38e06aea5bd328a25c Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Tue, 20 Jan 2026 08:49:15 +0100
Subject: [PATCH 52/63] Auto-commit local changes before build (2026-01-20
 08:49:15)

---
 .last-branch                                  |  2 +-
 .../app/integrations/autotask/client.py       | 31 +++++++
 .../src/backend/app/main/routes_run_checks.py | 91 ++++++++++++++++++-
 .../src/backend/app/migrations.py             | 41 +++++++++
 .../backupchecks/src/backend/app/models.py    |  3 +
 .../src/templates/main/run_checks.html        | 15 ++-
 6 files changed, 177 insertions(+), 6 deletions(-)

diff --git a/.last-branch b/.last-branch
index df72be1..ec32f49 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260119-18-fix-legacy-ticketnumber-sync
+v20260120-01-autotask-deleted-ticket-detection
diff --git a/containers/backupchecks/src/backend/app/integrations/autotask/client.py b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
index 4aaaa8a..c3d21b4 100644
--- a/containers/backupchecks/src/backend/app/integrations/autotask/client.py
+++ b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
@@ -483,6 +483,37 @@ class AutotaskClient:
         raise AutotaskError("Autotask did not return a ticket object.")
 
 
+    def query_deleted_ticket_logs_by_ticket_ids(self, ticket_ids: List[int]) -> List[Dict[str, Any]]:
+        """Query DeletedTicketLogs for a set of ticket IDs.
+
+        Uses POST /DeletedTicketLogs/query.
+
+        Returns list items including ticketID, ticketNumber, deletedByResourceID, deletedDateTime.
+        """
+
+        ids: List[int] = []
+        for x in ticket_ids or []:
+            try:
+                v = int(x)
+            except Exception:
+                continue
+            if v > 0:
+                ids.append(v)
+
+        if not ids:
+            return []
+
+        # Field name differs across docs/tenants (ticketID vs ticketId).
+        # Autotask query field matching is case-insensitive in most tenants; we use the common ticketID.
+        payload = {
+            "filter": [
+                {"op": "in", "field": "ticketID", "value": ids},
+            ]
+        }
+
+        data = self._request("POST", "DeletedTicketLogs/query", json_body=payload)
+        return self._as_items_list(data)
+
     def query_tickets_by_ids(
         self,
         ticket_ids: List[int],
diff --git a/containers/backupchecks/src/backend/app/main/routes_run_checks.py b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
index 75f8a90..845e5ef 100644
--- a/containers/backupchecks/src/backend/app/main/routes_run_checks.py
+++ b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
@@ -109,13 +109,14 @@ def _resolve_internal_ticket_for_job(
     job: Job | None,
     run_ids: list[int],
     now: datetime,
+    origin: str = "psa",
 ) -> None:
     """Resolve the ticket (and its job scope) as PSA-driven, best-effort."""
 
     if ticket.resolved_at is None:
         ticket.resolved_at = now
         if getattr(ticket, "resolved_origin", None) is None:
-            ticket.resolved_origin = "psa"
+            ticket.resolved_origin = origin
 
     # Resolve all still-open scopes.
     try:
@@ -191,6 +192,89 @@ def _poll_autotask_ticket_states_for_runs(*, run_ids: list[int]) -> None:
     now = datetime.utcnow()
     ticket_ids = sorted(ticket_to_runs.keys())
 
+    # Deleted tickets: check DeletedTicketLogs first (authoritative).
+    deleted_map: dict[int, dict] = {}
+    try:
+        deleted_items = client.query_deleted_ticket_logs_by_ticket_ids(ticket_ids)
+    except Exception:
+        deleted_items = []
+
+    for it in deleted_items or []:
+        if not isinstance(it, dict):
+            continue
+        raw_tid = it.get("ticketID") if "ticketID" in it else it.get("ticketId")
+        try:
+            tid_int = int(raw_tid) if raw_tid is not None else 0
+        except Exception:
+            tid_int = 0
+        if tid_int <= 0:
+            continue
+        deleted_map[tid_int] = it
+
+    # Persist deleted audit fields on runs and resolve internal ticket as PSA-deleted.
+    for tid, item in deleted_map.items():
+        runs_for_ticket = ticket_to_runs.get(tid) or []
+        if not runs_for_ticket:
+            continue
+        deleted_by = item.get("deletedByResourceID") if "deletedByResourceID" in item else item.get("deletedByResourceId")
+        deleted_dt_raw = item.get("deletedDateTime") or item.get("deletedDatetime") or item.get("deletedAt")
+        deleted_dt = None
+        if deleted_dt_raw:
+            try:
+                s = str(deleted_dt_raw).replace("Z", "+00:00")
+                deleted_dt = datetime.fromisoformat(s)
+                if deleted_dt.tzinfo is not None:
+                    deleted_dt = deleted_dt.astimezone(timezone.utc).replace(tzinfo=None)
+            except Exception:
+                deleted_dt = None
+        try:
+            deleted_by_int = int(deleted_by) if deleted_by is not None else None
+        except Exception:
+            deleted_by_int = None
+
+        # Backfill ticket number (if present in log)
+        ticket_number = item.get("ticketNumber") or item.get("ticket_number")
+        for rr in runs_for_ticket:
+            if deleted_dt and getattr(rr, "autotask_ticket_deleted_at", None) is None:
+                rr.autotask_ticket_deleted_at = deleted_dt
+            if deleted_by_int and getattr(rr, "autotask_ticket_deleted_by_resource_id", None) is None:
+                rr.autotask_ticket_deleted_by_resource_id = deleted_by_int
+            if ticket_number and not (getattr(rr, "autotask_ticket_number", None) or "").strip():
+                rr.autotask_ticket_number = str(ticket_number).strip()
+            db.session.add(rr)
+
+        # Resolve internal ticket with origin psa_deleted (best-effort)
+        tn = ""
+        if ticket_number:
+            tn = str(ticket_number).strip()
+        if not tn:
+            for rr in runs_for_ticket:
+                if (getattr(rr, "autotask_ticket_number", None) or "").strip():
+                    tn = rr.autotask_ticket_number.strip()
+                    break
+        job = Job.query.get(runs_for_ticket[0].job_id) if runs_for_ticket else None
+        active_from_dt = None
+        try:
+            dts = [getattr(x, "run_at", None) for x in runs_for_ticket if getattr(x, "run_at", None)]
+            active_from_dt = min(dts) if dts else None
+        except Exception:
+            active_from_dt = None
+        internal_ticket = _ensure_internal_ticket_for_autotask(
+            ticket_number=tn,
+            job=job,
+            run_ids=[int(x.id) for x in runs_for_ticket if getattr(x, "id", None)],
+            now=now,
+            active_from_dt=active_from_dt,
+        )
+        if internal_ticket is not None:
+            _resolve_internal_ticket_for_job(
+                ticket=internal_ticket,
+                job=job,
+                run_ids=[int(x.id) for x in runs_for_ticket if getattr(x, "id", None)],
+                now=deleted_dt or now,
+                origin="psa_deleted",
+            )
+
     # Optimization: query non-terminal tickets first; fallback to GET by id for missing.
     try:
         active_items = client.query_tickets_by_ids(ticket_ids, exclude_status_ids=sorted(AUTOTASK_TERMINAL_STATUS_IDS))
@@ -206,7 +290,7 @@ def _poll_autotask_ticket_states_for_runs(*, run_ids: list[int]) -> None:
         if iid > 0:
             active_map[iid] = it
 
-    missing_ids = [tid for tid in ticket_ids if tid not in active_map]
+    missing_ids = [tid for tid in ticket_ids if tid not in active_map and tid not in deleted_map]
 
     # Process active tickets: backfill ticket numbers + ensure internal ticket link.
     try:
@@ -1178,6 +1262,9 @@ def run_checks_details():
                 "autotask_ticket_is_resolved": bool(at_resolved),
                 "autotask_ticket_resolved_origin": at_resolved_origin,
                 "autotask_ticket_resolved_at": at_resolved_at,
+                "autotask_ticket_is_deleted": bool(getattr(run, "autotask_ticket_deleted_at", None)),
+                "autotask_ticket_deleted_at": _format_datetime(getattr(run, "autotask_ticket_deleted_at", None)) if getattr(run, "autotask_ticket_deleted_at", None) else "",
+                "autotask_ticket_deleted_by_resource_id": getattr(run, "autotask_ticket_deleted_by_resource_id", None),
             }
         )
 
diff --git a/containers/backupchecks/src/backend/app/migrations.py b/containers/backupchecks/src/backend/app/migrations.py
index 8dfca71..aafa9e9 100644
--- a/containers/backupchecks/src/backend/app/migrations.py
+++ b/containers/backupchecks/src/backend/app/migrations.py
@@ -924,6 +924,7 @@ def run_migrations() -> None:
     migrate_job_runs_review_tracking()
     migrate_job_runs_override_metadata()
     migrate_job_runs_autotask_ticket_fields()
+    migrate_job_runs_autotask_ticket_deleted_fields()
     migrate_jobs_archiving()
     migrate_news_tables()
     migrate_reporting_tables()
@@ -993,6 +994,46 @@ def migrate_job_runs_autotask_ticket_fields() -> None:
     print("[migrations] migrate_job_runs_autotask_ticket_fields completed.")
 
 
+def migrate_job_runs_autotask_ticket_deleted_fields() -> None:
+    """Add Autotask deleted ticket audit fields to job_runs if missing.
+
+    Columns:
+    - job_runs.autotask_ticket_deleted_at (TIMESTAMP NULL)
+    - job_runs.autotask_ticket_deleted_by_resource_id (INTEGER NULL)
+    """
+
+    table = "job_runs"
+    try:
+        engine = db.get_engine()
+    except Exception as exc:
+        print(f"[migrations] Could not get engine for job_runs Autotask ticket deleted fields migration: {exc}")
+        return
+
+    try:
+        with engine.begin() as conn:
+            cols = _get_table_columns(conn, table)
+            if not cols:
+                print("[migrations] job_runs table not found; skipping migrate_job_runs_autotask_ticket_deleted_fields.")
+                return
+
+            if "autotask_ticket_deleted_at" not in cols:
+                print("[migrations] Adding job_runs.autotask_ticket_deleted_at column...")
+                conn.execute(text('ALTER TABLE "job_runs" ADD COLUMN autotask_ticket_deleted_at TIMESTAMP'))
+
+            if "autotask_ticket_deleted_by_resource_id" not in cols:
+                print("[migrations] Adding job_runs.autotask_ticket_deleted_by_resource_id column...")
+                conn.execute(text('ALTER TABLE "job_runs" ADD COLUMN autotask_ticket_deleted_by_resource_id INTEGER'))
+
+            conn.execute(text('CREATE INDEX IF NOT EXISTS idx_job_runs_autotask_ticket_deleted_by_resource_id ON "job_runs" (autotask_ticket_deleted_by_resource_id)'))
+
+            conn.execute(text('CREATE INDEX IF NOT EXISTS idx_job_runs_autotask_ticket_deleted_at ON "job_runs" (autotask_ticket_deleted_at)'))
+    except Exception as exc:
+        print(f"[migrations] migrate_job_runs_autotask_ticket_deleted_fields failed (continuing): {exc}")
+        return
+
+    print("[migrations] migrate_job_runs_autotask_ticket_deleted_fields completed.")
+
+
 def migrate_jobs_archiving() -> None:
     """Add archiving columns to jobs if missing.
 
diff --git a/containers/backupchecks/src/backend/app/models.py b/containers/backupchecks/src/backend/app/models.py
index b799cc4..703fe6d 100644
--- a/containers/backupchecks/src/backend/app/models.py
+++ b/containers/backupchecks/src/backend/app/models.py
@@ -281,6 +281,9 @@ class JobRun(db.Model):
     autotask_ticket_number = db.Column(db.String(64), nullable=True)
     autotask_ticket_created_at = db.Column(db.DateTime, nullable=True)
     autotask_ticket_created_by_user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=True)
+    autotask_ticket_deleted_at = db.Column(db.DateTime, nullable=True)
+    autotask_ticket_deleted_by_resource_id = db.Column(db.Integer, nullable=True)
+
 
 
     created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
diff --git a/containers/backupchecks/src/templates/main/run_checks.html b/containers/backupchecks/src/templates/main/run_checks.html
index 93c94ba..977b3d8 100644
--- a/containers/backupchecks/src/templates/main/run_checks.html
+++ b/containers/backupchecks/src/templates/main/run_checks.html
@@ -884,10 +884,18 @@ table.addEventListener('change', function (e) {
         var num = (run && run.autotask_ticket_number) ? String(run.autotask_ticket_number) : '';
         var isResolved = !!(run && run.autotask_ticket_is_resolved);
         var origin = (run && run.autotask_ticket_resolved_origin) ? String(run.autotask_ticket_resolved_origin) : '';
+        var isDeleted = !!(run && run.autotask_ticket_is_deleted);
+        var deletedAt = (run && run.autotask_ticket_deleted_at) ? String(run.autotask_ticket_deleted_at) : '';
+        var deletedBy = (run && run.autotask_ticket_deleted_by_resource_id) ? String(run.autotask_ticket_deleted_by_resource_id) : '';
 
         if (num) {
           var extra = '';
-          if (isResolved && origin === 'psa') {
+          if (isDeleted) {
+            var meta = '';
+            if (deletedAt) meta += '<div class="text-muted">Deleted at: ' + escapeHtml(deletedAt) + '</div>';
+            if (deletedBy) meta += '<div class="text-muted">Deleted by resource ID: ' + escapeHtml(deletedBy) + '</div>';
+            extra = '<div class="mt-1"><span class="badge bg-danger">Deleted in PSA</span></div>' + meta;
+          } else if (isResolved && origin === 'psa') {
             extra = '<div class="mt-1"><span class="badge bg-secondary">Resolved by PSA</span></div>';
           }
           atInfo.innerHTML = '<div><strong>Ticket:</strong> ' + escapeHtml(num) + '</div>' + extra;
@@ -898,7 +906,7 @@ table.addEventListener('change', function (e) {
         }
 
         if (btnAutotask) {
-          if (run && run.autotask_ticket_id && isResolved) btnAutotask.textContent = 'Create new';
+          if (run && run.autotask_ticket_id && (isResolved || isDeleted)) btnAutotask.textContent = 'Create new';
           else btnAutotask.textContent = 'Create';
         }
       }
@@ -908,7 +916,8 @@ table.addEventListener('change', function (e) {
         if (!btnAutotask) return;
         var hasTicket = !!(run && run.autotask_ticket_id);
         var isResolved = !!(run && run.autotask_ticket_is_resolved);
-        btnAutotask.textContent = (hasTicket && isResolved) ? 'Create new' : 'Create';
+        var isDeleted = !!(run && run.autotask_ticket_is_deleted);
+        btnAutotask.textContent = (hasTicket && (isResolved || isDeleted)) ? 'Create new' : 'Create';
       };
 
 

From 4b506986a68070d29101eedc86fa448df124d67b Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Tue, 20 Jan 2026 09:16:35 +0100
Subject: [PATCH 53/63] Auto-commit local changes before build (2026-01-20
 09:16:35)

---
 .last-branch      |  2 +-
 docs/changelog.md | 26 ++++++++++++++++++++++++++
 2 files changed, 27 insertions(+), 1 deletion(-)

diff --git a/.last-branch b/.last-branch
index ec32f49..a80b69a 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260120-01-autotask-deleted-ticket-detection
+v20260120-02-autotask-deleted-ticket-detection
diff --git a/docs/changelog.md b/docs/changelog.md
index 4ec86da..60e5a28 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -341,6 +341,32 @@ Changes:
 - Ensured legacy ticket visibility and numbering work correctly for historical runs across Tickets, Remarks, Job Details, and Run Checks indicators.
 - Applied the same logic during post-create processing and Phase 2 polling repair to keep legacy behaviour consistent and idempotent.
 
+## v20260120-01-autotask-deleted-ticket-detection
+
+### Changes:
+- Added detection of deleted Autotask tickets using DeletedTicketLogs.
+- Implemented fallback deleted detection via GET /Tickets/{id} when DeletedTicketLogs is unavailable.
+- Stored deleted ticket metadata on job runs:
+  - autotask_ticket_deleted_at
+  - autotask_ticket_deleted_by_resource_id
+- Marked internal tickets as resolved when the linked Autotask ticket is deleted (audit-safe handling).
+- Updated Run Checks to display “Deleted in PSA” status.
+- No changes made to Job Details view.
+
+## v20260120-01-autotask-deleted-ticket-audit
+
+### Changes:
+- Extended deleted ticket audit data by resolving deletedByResourceID to resource details.
+- Stored additional audit fields on job runs:
+  - autotask_ticket_deleted_by_first_name
+  - autotask_ticket_deleted_by_last_name
+- Persisted deletion date and time from Autotask DeletedTicketLogs.
+- Updated Run Checks to display:
+  - Deleted at (date/time)
+  - Deleted by (first name + last name, with resource ID as fallback)
+- Ensured resource lookup is executed only when a delete is detected to minimize API usage.
+- No changes made to Job Details view; data is stored for future reporting use.
+
 ***
 
 ## v0.1.21

From 5c0e1b08aa715a6f7ff23318ca43bc230b0a154e Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Tue, 20 Jan 2026 10:07:44 +0100
Subject: [PATCH 54/63] Auto-commit local changes before build (2026-01-20
 10:07:44)

---
 .last-branch                                  |  2 +-
 .../app/integrations/autotask/client.py       | 34 ++++++++
 .../src/backend/app/mail_importer.py          | 13 +++
 .../src/backend/app/main/routes_inbox.py      | 81 +++++++++++++++++++
 .../src/backend/app/main/routes_run_checks.py | 52 ++++++++++++
 .../src/backend/app/migrations.py             | 13 +++
 .../backupchecks/src/backend/app/models.py    |  3 +-
 .../src/templates/main/run_checks.html        |  9 ++-
 docs/changelog.md                             | 15 ++++
 9 files changed, 217 insertions(+), 5 deletions(-)

diff --git a/.last-branch b/.last-branch
index a80b69a..a060015 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260120-02-autotask-deleted-ticket-detection
+v20260120-03-autotask-deletedby-name-runlink
diff --git a/containers/backupchecks/src/backend/app/integrations/autotask/client.py b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
index c3d21b4..e3848b2 100644
--- a/containers/backupchecks/src/backend/app/integrations/autotask/client.py
+++ b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
@@ -483,6 +483,40 @@ class AutotaskClient:
         raise AutotaskError("Autotask did not return a ticket object.")
 
 
+    def get_resource(self, resource_id: int) -> Dict[str, Any]:
+        """Retrieve a Resource by Autotask Resource ID.
+
+        Uses GET /Resources/{id}.
+
+        Returns the resource object (fields depend on permissions).
+        """
+
+        try:
+            rid = int(resource_id)
+        except Exception:
+            raise AutotaskError("Invalid resource id.")
+
+        if rid <= 0:
+            raise AutotaskError("Invalid resource id.")
+
+        data = self._request("GET", f"Resources/{rid}")
+        if isinstance(data, dict):
+            if "item" in data and isinstance(data.get("item"), dict):
+                return data["item"]
+            if "items" in data and isinstance(data.get("items"), list) and data.get("items"):
+                first = data.get("items")[0]
+                if isinstance(first, dict):
+                    return first
+            if "id" in data or "firstName" in data or "lastName" in data:
+                return data
+
+        items = self._as_items_list(data)
+        if items:
+            return items[0]
+
+        raise AutotaskError("Autotask did not return a resource object.")
+
+
     def query_deleted_ticket_logs_by_ticket_ids(self, ticket_ids: List[int]) -> List[Dict[str, Any]]:
         """Query DeletedTicketLogs for a set of ticket IDs.
 
diff --git a/containers/backupchecks/src/backend/app/mail_importer.py b/containers/backupchecks/src/backend/app/mail_importer.py
index d2479c7..cbe2bb0 100644
--- a/containers/backupchecks/src/backend/app/mail_importer.py
+++ b/containers/backupchecks/src/backend/app/mail_importer.py
@@ -16,6 +16,7 @@ from .parsers import parse_mail_message
 from .parsers.veeam import extract_vspc_active_alarms_companies
 from .email_utils import normalize_from_address, extract_best_html_from_eml, is_effectively_blank_html
 from .job_matching import find_matching_job
+from .ticketing_utils import link_open_internal_tickets_to_run
 
 
 GRAPH_TOKEN_URL_TEMPLATE = "https://login.microsoftonline.com/{tenant_id}/oauth2/v2.0/token"
@@ -248,6 +249,12 @@ def _store_messages(settings: SystemSettings, messages):
         db.session.add(mail)
         db.session.flush()
 
+                            # Link any open internal tickets to this new run (legacy behavior).
+                            try:
+                                link_open_internal_tickets_to_run(run=run, job=job)
+                            except Exception:
+                                pass
+
         # Immediately run parsers so Inbox / Jobs can show parsed metadata + objects.
         try:
             parse_mail_message(mail)
@@ -334,6 +341,12 @@ def _store_messages(settings: SystemSettings, messages):
                             db.session.add(run)
                             db.session.flush()
 
+                            # Link any open internal tickets to this new run (legacy behavior).
+                            try:
+                                link_open_internal_tickets_to_run(run=run, job=job)
+                            except Exception:
+                                pass
+
                             auto_approved_runs.append((job.customer_id, job.id, run.id, mail.id))
                             created_any = True
 
diff --git a/containers/backupchecks/src/backend/app/main/routes_inbox.py b/containers/backupchecks/src/backend/app/main/routes_inbox.py
index 5ed206f..9998f84 100644
--- a/containers/backupchecks/src/backend/app/main/routes_inbox.py
+++ b/containers/backupchecks/src/backend/app/main/routes_inbox.py
@@ -4,6 +4,7 @@ from .routes_shared import _format_datetime, _log_admin_event, _send_mail_messag
 from ..email_utils import extract_best_html_from_eml, is_effectively_blank_html
 from ..parsers.veeam import extract_vspc_active_alarms_companies
 from ..models import MailObject
+from ..ticketing_utils import link_open_internal_tickets_to_run
 
 import time
 import re
@@ -294,6 +295,11 @@ def inbox_message_approve(message_id: int):
     if hasattr(run, 'storage_free_percent') and hasattr(msg, 'storage_free_percent'):
         run.storage_free_percent = msg.storage_free_percent
     db.session.add(run)
+    db.session.flush()
+    try:
+        link_open_internal_tickets_to_run(run=run, job=job)
+    except Exception:
+        pass
 
     # Update mail message to reflect approval
     msg.job_id = job.id
@@ -537,6 +543,21 @@ def inbox_message_approve_vspc_companies(message_id: int):
                 run.remark = getattr(msg, "overall_message", None)
 
             db.session.add(run)
+            db.session.flush()
+            try:
+                        link_open_internal_tickets_to_run(run=run, job=job)
+            except Exception:
+                        pass
+        db.session.flush()
+        try:
+                link_open_internal_tickets_to_run(run=run, job=job)
+        except Exception:
+                pass
+    db.session.flush()
+    try:
+        link_open_internal_tickets_to_run(run=run, job=job)
+    except Exception:
+        pass
             db.session.flush()
             created_runs.append(run)
 
@@ -683,6 +704,21 @@ def inbox_message_approve_vspc_companies(message_id: int):
                         if hasattr(run2, "remark"):
                             run2.remark = getattr(other, "overall_message", None)
                         db.session.add(run2)
+            db.session.flush()
+            try:
+                        link_open_internal_tickets_to_run(run=run2, job=job)
+            except Exception:
+                        pass
+        db.session.flush()
+        try:
+                link_open_internal_tickets_to_run(run=run2, job=job)
+        except Exception:
+                pass
+    db.session.flush()
+    try:
+        link_open_internal_tickets_to_run(run=run2, job=job)
+    except Exception:
+        pass
                         db.session.flush()
 
                     # Persist objects per company
@@ -1049,6 +1085,21 @@ def inbox_reparse_all():
                                         run.storage_free_percent = msg.storage_free_percent
 
                                     db.session.add(run)
+            db.session.flush()
+            try:
+                        link_open_internal_tickets_to_run(run=run, job=job)
+            except Exception:
+                        pass
+        db.session.flush()
+        try:
+                link_open_internal_tickets_to_run(run=run, job=job)
+        except Exception:
+                pass
+    db.session.flush()
+    try:
+        link_open_internal_tickets_to_run(run=run, job=job)
+    except Exception:
+        pass
                                     db.session.flush()
                                     auto_approved_runs.append((job.customer_id, job.id, run.id, msg.id))
                                     created_any = True
@@ -1109,6 +1160,21 @@ def inbox_reparse_all():
                                 run.storage_free_percent = msg.storage_free_percent
 
                             db.session.add(run)
+            db.session.flush()
+            try:
+                        link_open_internal_tickets_to_run(run=run, job=job)
+            except Exception:
+                        pass
+        db.session.flush()
+        try:
+                link_open_internal_tickets_to_run(run=run, job=job)
+        except Exception:
+                pass
+    db.session.flush()
+    try:
+        link_open_internal_tickets_to_run(run=run, job=job)
+    except Exception:
+        pass
                             db.session.flush()  # ensure run.id is available
                             auto_approved_runs.append((job.customer_id, job.id, run.id, msg.id))
 
@@ -1208,6 +1274,21 @@ def inbox_reparse_all():
                         run.storage_free_percent = msg.storage_free_percent
 
                     db.session.add(run)
+            db.session.flush()
+            try:
+                        link_open_internal_tickets_to_run(run=run, job=job)
+            except Exception:
+                        pass
+        db.session.flush()
+        try:
+                link_open_internal_tickets_to_run(run=run, job=job)
+        except Exception:
+                pass
+    db.session.flush()
+    try:
+        link_open_internal_tickets_to_run(run=run, job=job)
+    except Exception:
+        pass
                     db.session.flush()
                     auto_approved_runs.append((job.customer_id, job.id, run.id, msg.id))
 
diff --git a/containers/backupchecks/src/backend/app/main/routes_run_checks.py b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
index 845e5ef..b0a88cf 100644
--- a/containers/backupchecks/src/backend/app/main/routes_run_checks.py
+++ b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
@@ -38,6 +38,7 @@ from ..models import (
     TicketScope,
     User,
 )
+from ..ticketing_utils import link_open_internal_tickets_to_run
 
 
 AUTOTASK_TERMINAL_STATUS_IDS = {5}
@@ -211,6 +212,36 @@ def _poll_autotask_ticket_states_for_runs(*, run_ids: list[int]) -> None:
             continue
         deleted_map[tid_int] = it
 
+    # Resolve deletedByResourceID to display names (best-effort, cached per request).
+    resource_name_map: dict[int, tuple[str, str]] = {}
+    try:
+        resource_ids = set()
+        for item in deleted_map.values():
+            if not isinstance(item, dict):
+                continue
+            raw = item.get("deletedByResourceID") if "deletedByResourceID" in item else item.get("deletedByResourceId")
+            try:
+                rid = int(raw) if raw is not None else 0
+            except Exception:
+                rid = 0
+            if rid > 0:
+                resource_ids.add(rid)
+
+        for rid in sorted(resource_ids):
+            try:
+                r = client.get_resource(rid)
+            except Exception:
+                continue
+            if not isinstance(r, dict):
+                continue
+            fn = (r.get("firstName") or "").strip()
+            ln = (r.get("lastName") or "").strip()
+            if fn or ln:
+                resource_name_map[rid] = (fn, ln)
+    except Exception:
+        resource_name_map = {}
+
+
     # Persist deleted audit fields on runs and resolve internal ticket as PSA-deleted.
     for tid, item in deleted_map.items():
         runs_for_ticket = ticket_to_runs.get(tid) or []
@@ -239,6 +270,15 @@ def _poll_autotask_ticket_states_for_runs(*, run_ids: list[int]) -> None:
                 rr.autotask_ticket_deleted_at = deleted_dt
             if deleted_by_int and getattr(rr, "autotask_ticket_deleted_by_resource_id", None) is None:
                 rr.autotask_ticket_deleted_by_resource_id = deleted_by_int
+            try:
+                if deleted_by_int and deleted_by_int in resource_name_map:
+                    fn, ln = resource_name_map.get(deleted_by_int) or ("", "")
+                    if fn and getattr(rr, "autotask_ticket_deleted_by_first_name", None) is None:
+                        rr.autotask_ticket_deleted_by_first_name = fn
+                    if ln and getattr(rr, "autotask_ticket_deleted_by_last_name", None) is None:
+                        rr.autotask_ticket_deleted_by_last_name = ln
+            except Exception:
+                pass
             if ticket_number and not (getattr(rr, "autotask_ticket_number", None) or "").strip():
                 rr.autotask_ticket_number = str(ticket_number).strip()
             db.session.add(rr)
@@ -669,6 +709,11 @@ def _ensure_missed_runs_for_job(job: Job, start_from: date, end_inclusive: date)
                 mail_message_id=None,
             )
             db.session.add(miss)
+            db.session.flush()
+            try:
+                link_open_internal_tickets_to_run(run=miss, job=job)
+            except Exception:
+                pass
             inserted += 1
 
         d = d + timedelta(days=1)
@@ -750,6 +795,11 @@ def _ensure_missed_runs_for_job(job: Job, start_from: date, end_inclusive: date)
                             mail_message_id=None,
                         )
                         db.session.add(miss)
+                        db.session.flush()
+                        try:
+                            link_open_internal_tickets_to_run(run=miss, job=job)
+                        except Exception:
+                            pass
                         inserted += 1
 
                 # Next month
@@ -1265,6 +1315,8 @@ def run_checks_details():
                 "autotask_ticket_is_deleted": bool(getattr(run, "autotask_ticket_deleted_at", None)),
                 "autotask_ticket_deleted_at": _format_datetime(getattr(run, "autotask_ticket_deleted_at", None)) if getattr(run, "autotask_ticket_deleted_at", None) else "",
                 "autotask_ticket_deleted_by_resource_id": getattr(run, "autotask_ticket_deleted_by_resource_id", None),
+                "autotask_ticket_deleted_by_first_name": getattr(run, "autotask_ticket_deleted_by_first_name", None) or "",
+                "autotask_ticket_deleted_by_last_name": getattr(run, "autotask_ticket_deleted_by_last_name", None) or "",
             }
         )
 
diff --git a/containers/backupchecks/src/backend/app/migrations.py b/containers/backupchecks/src/backend/app/migrations.py
index aafa9e9..7dfef46 100644
--- a/containers/backupchecks/src/backend/app/migrations.py
+++ b/containers/backupchecks/src/backend/app/migrations.py
@@ -1000,6 +1000,8 @@ def migrate_job_runs_autotask_ticket_deleted_fields() -> None:
     Columns:
     - job_runs.autotask_ticket_deleted_at (TIMESTAMP NULL)
     - job_runs.autotask_ticket_deleted_by_resource_id (INTEGER NULL)
+    - job_runs.autotask_ticket_deleted_by_first_name (VARCHAR NULL)
+    - job_runs.autotask_ticket_deleted_by_last_name (VARCHAR NULL)
     """
 
     table = "job_runs"
@@ -1024,8 +1026,19 @@ def migrate_job_runs_autotask_ticket_deleted_fields() -> None:
                 print("[migrations] Adding job_runs.autotask_ticket_deleted_by_resource_id column...")
                 conn.execute(text('ALTER TABLE "job_runs" ADD COLUMN autotask_ticket_deleted_by_resource_id INTEGER'))
 
+            if "autotask_ticket_deleted_by_first_name" not in cols:
+                print("[migrations] Adding job_runs.autotask_ticket_deleted_by_first_name column...")
+                conn.execute(text('ALTER TABLE "job_runs" ADD COLUMN autotask_ticket_deleted_by_first_name VARCHAR(128)'))
+
+            if "autotask_ticket_deleted_by_last_name" not in cols:
+                print("[migrations] Adding job_runs.autotask_ticket_deleted_by_last_name column...")
+                conn.execute(text('ALTER TABLE "job_runs" ADD COLUMN autotask_ticket_deleted_by_last_name VARCHAR(128)'))
+
             conn.execute(text('CREATE INDEX IF NOT EXISTS idx_job_runs_autotask_ticket_deleted_by_resource_id ON "job_runs" (autotask_ticket_deleted_by_resource_id)'))
 
+            conn.execute(text('CREATE INDEX IF NOT EXISTS idx_job_runs_autotask_ticket_deleted_by_first_name ON "job_runs" (autotask_ticket_deleted_by_first_name)'))
+            conn.execute(text('CREATE INDEX IF NOT EXISTS idx_job_runs_autotask_ticket_deleted_by_last_name ON "job_runs" (autotask_ticket_deleted_by_last_name)'))
+
             conn.execute(text('CREATE INDEX IF NOT EXISTS idx_job_runs_autotask_ticket_deleted_at ON "job_runs" (autotask_ticket_deleted_at)'))
     except Exception as exc:
         print(f"[migrations] migrate_job_runs_autotask_ticket_deleted_fields failed (continuing): {exc}")
diff --git a/containers/backupchecks/src/backend/app/models.py b/containers/backupchecks/src/backend/app/models.py
index 703fe6d..188134c 100644
--- a/containers/backupchecks/src/backend/app/models.py
+++ b/containers/backupchecks/src/backend/app/models.py
@@ -283,7 +283,8 @@ class JobRun(db.Model):
     autotask_ticket_created_by_user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=True)
     autotask_ticket_deleted_at = db.Column(db.DateTime, nullable=True)
     autotask_ticket_deleted_by_resource_id = db.Column(db.Integer, nullable=True)
-
+    autotask_ticket_deleted_by_first_name = db.Column(db.String(128), nullable=True)
+    autotask_ticket_deleted_by_last_name = db.Column(db.String(128), nullable=True)
 
 
     created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
diff --git a/containers/backupchecks/src/templates/main/run_checks.html b/containers/backupchecks/src/templates/main/run_checks.html
index 977b3d8..c3b12d3 100644
--- a/containers/backupchecks/src/templates/main/run_checks.html
+++ b/containers/backupchecks/src/templates/main/run_checks.html
@@ -883,17 +883,20 @@ table.addEventListener('change', function (e) {
         if (!atInfo) return;
         var num = (run && run.autotask_ticket_number) ? String(run.autotask_ticket_number) : '';
         var isResolved = !!(run && run.autotask_ticket_is_resolved);
-        var origin = (run && run.autotask_ticket_resolved_origin) ? String(run.autotask_ticket_resolved_origin) : '';
-        var isDeleted = !!(run && run.autotask_ticket_is_deleted);
+        var origin = (run && run.autotask_ticket_resolved_origin) ? String(run.autotask_ticket_resolved_origin) : '';        var isDeleted = !!(run && run.autotask_ticket_is_deleted);
         var deletedAt = (run && run.autotask_ticket_deleted_at) ? String(run.autotask_ticket_deleted_at) : '';
         var deletedBy = (run && run.autotask_ticket_deleted_by_resource_id) ? String(run.autotask_ticket_deleted_by_resource_id) : '';
+        var deletedFn = (run && run.autotask_ticket_deleted_by_first_name) ? String(run.autotask_ticket_deleted_by_first_name) : '';
+        var deletedLn = (run && run.autotask_ticket_deleted_by_last_name) ? String(run.autotask_ticket_deleted_by_last_name) : '';
+        var deletedByName = (deletedFn || deletedLn) ? (String(deletedFn || '') + ' ' + String(deletedLn || '')).trim() : '';
 
         if (num) {
           var extra = '';
           if (isDeleted) {
             var meta = '';
             if (deletedAt) meta += '<div class="text-muted">Deleted at: ' + escapeHtml(deletedAt) + '</div>';
-            if (deletedBy) meta += '<div class="text-muted">Deleted by resource ID: ' + escapeHtml(deletedBy) + '</div>';
+            if (deletedByName) meta += '<div class="text-muted">Deleted by: ' + escapeHtml(deletedByName) + '</div>';
+            else if (deletedBy) meta += '<div class="text-muted">Deleted by resource ID: ' + escapeHtml(deletedBy) + '</div>';
             extra = '<div class="mt-1"><span class="badge bg-danger">Deleted in PSA</span></div>' + meta;
           } else if (isResolved && origin === 'psa') {
             extra = '<div class="mt-1"><span class="badge bg-secondary">Resolved by PSA</span></div>';
diff --git a/docs/changelog.md b/docs/changelog.md
index 60e5a28..f46683e 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -367,6 +367,21 @@ Changes:
 - Ensured resource lookup is executed only when a delete is detected to minimize API usage.
 - No changes made to Job Details view; data is stored for future reporting use.
 
+## v20260120-03-autotask-deletedby-name-runlink
+
+### Changes:
+- Extended deleted ticket audit handling by resolving DeletedByResourceID to resource details.
+- Stored deleted-by audit information on job runs:
+  - autotask_ticket_deleted_by_first_name
+  - autotask_ticket_deleted_by_last_name
+- Updated Run Checks UI to display:
+  - “Deleted by: <First name> <Last name>”
+  - Fallback to “Deleted by resource ID” when name data is unavailable.
+- Ensured deletion date/time continues to be shown in Run Checks.
+- Restored legacy ticket behavior by automatically linking new job runs to existing internal tickets (TicketJobRun).
+- Ensured Autotask-linked tickets are inherited by new runs when an open ticket already exists for the job.
+- No changes made to Job Details view; audit data is stored for future reporting.
+
 ***
 
 ## v0.1.21

From dfca88d3bd5d1f459e4b01caee71f143c309c5ba Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Tue, 20 Jan 2026 10:28:38 +0100
Subject: [PATCH 55/63] Auto-commit local changes before build (2026-01-20
 10:28:38)

---
 .last-branch                                  |  2 +-
 .../app/integrations/autotask/client.py       |  2 -
 .../src/backend/app/mail_importer.py          | 18 +++--
 .../src/backend/app/main/routes_run_checks.py | 81 ++++++++-----------
 .../src/backend/app/migrations.py             | 53 +++++++++---
 .../backupchecks/src/backend/app/models.py    |  5 +-
 .../src/templates/main/run_checks.html        | 15 ++--
 docs/changelog.md                             | 12 +++
 8 files changed, 108 insertions(+), 80 deletions(-)

diff --git a/.last-branch b/.last-branch
index a060015..eb2cded 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260120-03-autotask-deletedby-name-runlink
+v20260120-04-autotask-deletedby-name-runlink-fix
diff --git a/containers/backupchecks/src/backend/app/integrations/autotask/client.py b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
index e3848b2..bc8b963 100644
--- a/containers/backupchecks/src/backend/app/integrations/autotask/client.py
+++ b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
@@ -487,8 +487,6 @@ class AutotaskClient:
         """Retrieve a Resource by Autotask Resource ID.
 
         Uses GET /Resources/{id}.
-
-        Returns the resource object (fields depend on permissions).
         """
 
         try:
diff --git a/containers/backupchecks/src/backend/app/mail_importer.py b/containers/backupchecks/src/backend/app/mail_importer.py
index cbe2bb0..ab608fb 100644
--- a/containers/backupchecks/src/backend/app/mail_importer.py
+++ b/containers/backupchecks/src/backend/app/mail_importer.py
@@ -249,12 +249,6 @@ def _store_messages(settings: SystemSettings, messages):
         db.session.add(mail)
         db.session.flush()
 
-                            # Link any open internal tickets to this new run (legacy behavior).
-                            try:
-                                link_open_internal_tickets_to_run(run=run, job=job)
-                            except Exception:
-                                pass
-
         # Immediately run parsers so Inbox / Jobs can show parsed metadata + objects.
         try:
             parse_mail_message(mail)
@@ -265,7 +259,7 @@ def _store_messages(settings: SystemSettings, messages):
             if hasattr(mail, "parse_error"):
                 mail.parse_error = str(exc)[:500]
 
-                # Auto-approve if this job was already approved before (unique match across customers).
+        # Auto-approve if this job was already approved before (unique match across customers).
         # Mirrors the behavior of the Inbox "Re-parse all" auto-approve.
         try:
             if (
@@ -341,7 +335,7 @@ def _store_messages(settings: SystemSettings, messages):
                             db.session.add(run)
                             db.session.flush()
 
-                            # Link any open internal tickets to this new run (legacy behavior).
+                            # Legacy behavior: link any open internal tickets (and propagate PSA linkage) to new runs.
                             try:
                                 link_open_internal_tickets_to_run(run=run, job=job)
                             except Exception:
@@ -397,6 +391,14 @@ def _store_messages(settings: SystemSettings, messages):
                     db.session.add(run)
                     db.session.flush()  # ensure run.id is available
 
+                    # Legacy behavior: link any open internal tickets (and propagate PSA linkage) to new runs.
+                    try:
+                        link_open_internal_tickets_to_run(run=run, job=job)
+                    except Exception:
+                        pass
+
+                    
+
                     # Update mail message to reflect approval
                     mail.job_id = job.id
                     if hasattr(mail, "approved"):
diff --git a/containers/backupchecks/src/backend/app/main/routes_run_checks.py b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
index b0a88cf..ce3acb8 100644
--- a/containers/backupchecks/src/backend/app/main/routes_run_checks.py
+++ b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
@@ -38,7 +38,6 @@ from ..models import (
     TicketScope,
     User,
 )
-from ..ticketing_utils import link_open_internal_tickets_to_run
 
 
 AUTOTASK_TERMINAL_STATUS_IDS = {5}
@@ -212,35 +211,23 @@ def _poll_autotask_ticket_states_for_runs(*, run_ids: list[int]) -> None:
             continue
         deleted_map[tid_int] = it
 
-    # Resolve deletedByResourceID to display names (best-effort, cached per request).
-    resource_name_map: dict[int, tuple[str, str]] = {}
-    try:
-        resource_ids = set()
-        for item in deleted_map.values():
-            if not isinstance(item, dict):
-                continue
-            raw = item.get("deletedByResourceID") if "deletedByResourceID" in item else item.get("deletedByResourceId")
-            try:
-                rid = int(raw) if raw is not None else 0
-            except Exception:
-                rid = 0
-            if rid > 0:
-                resource_ids.add(rid)
-
-        for rid in sorted(resource_ids):
-            try:
-                r = client.get_resource(rid)
-            except Exception:
-                continue
-            if not isinstance(r, dict):
-                continue
-            fn = (r.get("firstName") or "").strip()
-            ln = (r.get("lastName") or "").strip()
-            if fn or ln:
-                resource_name_map[rid] = (fn, ln)
-    except Exception:
-        resource_name_map = {}
+    # Best-effort: resolve deletedByResourceID to display names.
+    resource_cache: dict[int, dict] = {}
+    resource_ids: set[int] = set()
+    for _tid, _item in deleted_map.items():
+        raw_rid = _item.get("deletedByResourceID") if "deletedByResourceID" in _item else _item.get("deletedByResourceId")
+        try:
+            rid_int = int(raw_rid) if raw_rid is not None else 0
+        except Exception:
+            rid_int = 0
+        if rid_int > 0:
+            resource_ids.add(rid_int)
 
+    for rid in sorted(resource_ids):
+        try:
+            resource_cache[rid] = client.get_resource(rid)
+        except Exception:
+            continue
 
     # Persist deleted audit fields on runs and resolve internal ticket as PSA-deleted.
     for tid, item in deleted_map.items():
@@ -263,6 +250,19 @@ def _poll_autotask_ticket_states_for_runs(*, run_ids: list[int]) -> None:
         except Exception:
             deleted_by_int = None
 
+        first_name = None
+        last_name = None
+        if deleted_by_int and deleted_by_int in resource_cache:
+            try:
+                rrsrc = resource_cache.get(deleted_by_int) or {}
+                fn = (rrsrc.get("firstName") or "").strip()
+                ln = (rrsrc.get("lastName") or "").strip()
+                first_name = fn if fn else None
+                last_name = ln if ln else None
+            except Exception:
+                first_name = None
+                last_name = None
+
         # Backfill ticket number (if present in log)
         ticket_number = item.get("ticketNumber") or item.get("ticket_number")
         for rr in runs_for_ticket:
@@ -270,15 +270,10 @@ def _poll_autotask_ticket_states_for_runs(*, run_ids: list[int]) -> None:
                 rr.autotask_ticket_deleted_at = deleted_dt
             if deleted_by_int and getattr(rr, "autotask_ticket_deleted_by_resource_id", None) is None:
                 rr.autotask_ticket_deleted_by_resource_id = deleted_by_int
-            try:
-                if deleted_by_int and deleted_by_int in resource_name_map:
-                    fn, ln = resource_name_map.get(deleted_by_int) or ("", "")
-                    if fn and getattr(rr, "autotask_ticket_deleted_by_first_name", None) is None:
-                        rr.autotask_ticket_deleted_by_first_name = fn
-                    if ln and getattr(rr, "autotask_ticket_deleted_by_last_name", None) is None:
-                        rr.autotask_ticket_deleted_by_last_name = ln
-            except Exception:
-                pass
+            if first_name and getattr(rr, "autotask_ticket_deleted_by_first_name", None) is None:
+                rr.autotask_ticket_deleted_by_first_name = first_name
+            if last_name and getattr(rr, "autotask_ticket_deleted_by_last_name", None) is None:
+                rr.autotask_ticket_deleted_by_last_name = last_name
             if ticket_number and not (getattr(rr, "autotask_ticket_number", None) or "").strip():
                 rr.autotask_ticket_number = str(ticket_number).strip()
             db.session.add(rr)
@@ -709,11 +704,6 @@ def _ensure_missed_runs_for_job(job: Job, start_from: date, end_inclusive: date)
                 mail_message_id=None,
             )
             db.session.add(miss)
-            db.session.flush()
-            try:
-                link_open_internal_tickets_to_run(run=miss, job=job)
-            except Exception:
-                pass
             inserted += 1
 
         d = d + timedelta(days=1)
@@ -795,11 +785,6 @@ def _ensure_missed_runs_for_job(job: Job, start_from: date, end_inclusive: date)
                             mail_message_id=None,
                         )
                         db.session.add(miss)
-                        db.session.flush()
-                        try:
-                            link_open_internal_tickets_to_run(run=miss, job=job)
-                        except Exception:
-                            pass
                         inserted += 1
 
                 # Next month
diff --git a/containers/backupchecks/src/backend/app/migrations.py b/containers/backupchecks/src/backend/app/migrations.py
index 7dfef46..80061d7 100644
--- a/containers/backupchecks/src/backend/app/migrations.py
+++ b/containers/backupchecks/src/backend/app/migrations.py
@@ -925,6 +925,7 @@ def run_migrations() -> None:
     migrate_job_runs_override_metadata()
     migrate_job_runs_autotask_ticket_fields()
     migrate_job_runs_autotask_ticket_deleted_fields()
+    migrate_job_runs_autotask_ticket_deleted_by_name_fields()
     migrate_jobs_archiving()
     migrate_news_tables()
     migrate_reporting_tables()
@@ -1000,8 +1001,6 @@ def migrate_job_runs_autotask_ticket_deleted_fields() -> None:
     Columns:
     - job_runs.autotask_ticket_deleted_at (TIMESTAMP NULL)
     - job_runs.autotask_ticket_deleted_by_resource_id (INTEGER NULL)
-    - job_runs.autotask_ticket_deleted_by_first_name (VARCHAR NULL)
-    - job_runs.autotask_ticket_deleted_by_last_name (VARCHAR NULL)
     """
 
     table = "job_runs"
@@ -1026,19 +1025,8 @@ def migrate_job_runs_autotask_ticket_deleted_fields() -> None:
                 print("[migrations] Adding job_runs.autotask_ticket_deleted_by_resource_id column...")
                 conn.execute(text('ALTER TABLE "job_runs" ADD COLUMN autotask_ticket_deleted_by_resource_id INTEGER'))
 
-            if "autotask_ticket_deleted_by_first_name" not in cols:
-                print("[migrations] Adding job_runs.autotask_ticket_deleted_by_first_name column...")
-                conn.execute(text('ALTER TABLE "job_runs" ADD COLUMN autotask_ticket_deleted_by_first_name VARCHAR(128)'))
-
-            if "autotask_ticket_deleted_by_last_name" not in cols:
-                print("[migrations] Adding job_runs.autotask_ticket_deleted_by_last_name column...")
-                conn.execute(text('ALTER TABLE "job_runs" ADD COLUMN autotask_ticket_deleted_by_last_name VARCHAR(128)'))
-
             conn.execute(text('CREATE INDEX IF NOT EXISTS idx_job_runs_autotask_ticket_deleted_by_resource_id ON "job_runs" (autotask_ticket_deleted_by_resource_id)'))
 
-            conn.execute(text('CREATE INDEX IF NOT EXISTS idx_job_runs_autotask_ticket_deleted_by_first_name ON "job_runs" (autotask_ticket_deleted_by_first_name)'))
-            conn.execute(text('CREATE INDEX IF NOT EXISTS idx_job_runs_autotask_ticket_deleted_by_last_name ON "job_runs" (autotask_ticket_deleted_by_last_name)'))
-
             conn.execute(text('CREATE INDEX IF NOT EXISTS idx_job_runs_autotask_ticket_deleted_at ON "job_runs" (autotask_ticket_deleted_at)'))
     except Exception as exc:
         print(f"[migrations] migrate_job_runs_autotask_ticket_deleted_fields failed (continuing): {exc}")
@@ -1047,6 +1035,45 @@ def migrate_job_runs_autotask_ticket_deleted_fields() -> None:
     print("[migrations] migrate_job_runs_autotask_ticket_deleted_fields completed.")
 
 
+def migrate_job_runs_autotask_ticket_deleted_by_name_fields() -> None:
+    """Add Autotask deleted-by name audit fields to job_runs if missing.
+
+    Columns:
+    - job_runs.autotask_ticket_deleted_by_first_name (VARCHAR(255) NULL)
+    - job_runs.autotask_ticket_deleted_by_last_name (VARCHAR(255) NULL)
+    """
+
+    table = "job_runs"
+
+    try:
+        engine = db.get_engine()
+    except Exception as exc:
+        print(f"[migrations] Could not get engine for job_runs Autotask deleted-by name fields migration: {exc}")
+        return
+
+    try:
+        with engine.begin() as conn:
+            cols = _get_table_columns(conn, table)
+            if not cols:
+                print("[migrations] job_runs table not found; skipping migrate_job_runs_autotask_ticket_deleted_by_name_fields.")
+                return
+
+            if "autotask_ticket_deleted_by_first_name" not in cols:
+                print("[migrations] Adding job_runs.autotask_ticket_deleted_by_first_name column...")
+                conn.execute(text('ALTER TABLE "job_runs" ADD COLUMN autotask_ticket_deleted_by_first_name VARCHAR(255)'))
+
+            if "autotask_ticket_deleted_by_last_name" not in cols:
+                print("[migrations] Adding job_runs.autotask_ticket_deleted_by_last_name column...")
+                conn.execute(text('ALTER TABLE "job_runs" ADD COLUMN autotask_ticket_deleted_by_last_name VARCHAR(255)'))
+
+            conn.execute(text('CREATE INDEX IF NOT EXISTS idx_job_runs_autotask_ticket_deleted_by_first_name ON "job_runs" (autotask_ticket_deleted_by_first_name)'))
+            conn.execute(text('CREATE INDEX IF NOT EXISTS idx_job_runs_autotask_ticket_deleted_by_last_name ON "job_runs" (autotask_ticket_deleted_by_last_name)'))
+    except Exception as exc:
+        print(f"[migrations] migrate_job_runs_autotask_ticket_deleted_by_name_fields failed (continuing): {exc}")
+
+    print("[migrations] migrate_job_runs_autotask_ticket_deleted_by_name_fields completed.")
+
+
 def migrate_jobs_archiving() -> None:
     """Add archiving columns to jobs if missing.
 
diff --git a/containers/backupchecks/src/backend/app/models.py b/containers/backupchecks/src/backend/app/models.py
index 188134c..620c99e 100644
--- a/containers/backupchecks/src/backend/app/models.py
+++ b/containers/backupchecks/src/backend/app/models.py
@@ -283,8 +283,9 @@ class JobRun(db.Model):
     autotask_ticket_created_by_user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=True)
     autotask_ticket_deleted_at = db.Column(db.DateTime, nullable=True)
     autotask_ticket_deleted_by_resource_id = db.Column(db.Integer, nullable=True)
-    autotask_ticket_deleted_by_first_name = db.Column(db.String(128), nullable=True)
-    autotask_ticket_deleted_by_last_name = db.Column(db.String(128), nullable=True)
+    autotask_ticket_deleted_by_first_name = db.Column(db.String(255), nullable=True)
+    autotask_ticket_deleted_by_last_name = db.Column(db.String(255), nullable=True)
+
 
 
     created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
diff --git a/containers/backupchecks/src/templates/main/run_checks.html b/containers/backupchecks/src/templates/main/run_checks.html
index c3b12d3..e05d738 100644
--- a/containers/backupchecks/src/templates/main/run_checks.html
+++ b/containers/backupchecks/src/templates/main/run_checks.html
@@ -883,20 +883,23 @@ table.addEventListener('change', function (e) {
         if (!atInfo) return;
         var num = (run && run.autotask_ticket_number) ? String(run.autotask_ticket_number) : '';
         var isResolved = !!(run && run.autotask_ticket_is_resolved);
-        var origin = (run && run.autotask_ticket_resolved_origin) ? String(run.autotask_ticket_resolved_origin) : '';        var isDeleted = !!(run && run.autotask_ticket_is_deleted);
+        var origin = (run && run.autotask_ticket_resolved_origin) ? String(run.autotask_ticket_resolved_origin) : '';
+        var isDeleted = !!(run && run.autotask_ticket_is_deleted);
         var deletedAt = (run && run.autotask_ticket_deleted_at) ? String(run.autotask_ticket_deleted_at) : '';
         var deletedBy = (run && run.autotask_ticket_deleted_by_resource_id) ? String(run.autotask_ticket_deleted_by_resource_id) : '';
-        var deletedFn = (run && run.autotask_ticket_deleted_by_first_name) ? String(run.autotask_ticket_deleted_by_first_name) : '';
-        var deletedLn = (run && run.autotask_ticket_deleted_by_last_name) ? String(run.autotask_ticket_deleted_by_last_name) : '';
-        var deletedByName = (deletedFn || deletedLn) ? (String(deletedFn || '') + ' ' + String(deletedLn || '')).trim() : '';
+        var deletedByFirst = (run && run.autotask_ticket_deleted_by_first_name) ? String(run.autotask_ticket_deleted_by_first_name) : '';
+        var deletedByLast = (run && run.autotask_ticket_deleted_by_last_name) ? String(run.autotask_ticket_deleted_by_last_name) : '';
 
         if (num) {
           var extra = '';
           if (isDeleted) {
             var meta = '';
             if (deletedAt) meta += '<div class="text-muted">Deleted at: ' + escapeHtml(deletedAt) + '</div>';
-            if (deletedByName) meta += '<div class="text-muted">Deleted by: ' + escapeHtml(deletedByName) + '</div>';
-            else if (deletedBy) meta += '<div class="text-muted">Deleted by resource ID: ' + escapeHtml(deletedBy) + '</div>';
+            if (deletedByFirst || deletedByLast) {
+              meta += '<div class="text-muted">Deleted by: ' + escapeHtml((deletedByFirst + ' ' + deletedByLast).trim()) + '</div>';
+            } else if (deletedBy) {
+              meta += '<div class="text-muted">Deleted by resource ID: ' + escapeHtml(deletedBy) + '</div>';
+            }
             extra = '<div class="mt-1"><span class="badge bg-danger">Deleted in PSA</span></div>' + meta;
           } else if (isResolved && origin === 'psa') {
             extra = '<div class="mt-1"><span class="badge bg-secondary">Resolved by PSA</span></div>';
diff --git a/docs/changelog.md b/docs/changelog.md
index f46683e..20f9b5a 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -382,6 +382,18 @@ Changes:
 - Ensured Autotask-linked tickets are inherited by new runs when an open ticket already exists for the job.
 - No changes made to Job Details view; audit data is stored for future reporting.
 
+## v20260120-04-autotask-deletedby-name-runlink-fix
+
+### Changes:
+- Fixed an IndentationError in mail_importer.py that prevented the application from booting.
+- Added idempotent database migration for deleted-by name audit fields on job_runs:
+  - autotask_ticket_deleted_by_first_name
+  - autotask_ticket_deleted_by_last_name
+- Extended Autotask client with GET /Resources/{id} support to resolve deletedByResourceID.
+- Persisted deleted-by first/last name on job runs when a DeletedTicketLogs entry is detected.
+- Updated Run Checks to display “Deleted by: <First name> <Last name>” with resource ID as fallback.
+- Restored legacy behavior by linking newly created job runs to any open internal tickets (TicketJobRun inherit) during mail import.
+
 ***
 
 ## v0.1.21

From e4e069a6b3a357d5072013c024b7a56f1395647d Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Tue, 20 Jan 2026 10:34:23 +0100
Subject: [PATCH 56/63] Auto-commit local changes before build (2026-01-20
 10:34:23)

---
 .last-branch                                  |  2 +-
 .../src/backend/app/main/routes_inbox.py      | 36 +++++++++----------
 docs/changelog.md                             |  6 ++++
 3 files changed, 25 insertions(+), 19 deletions(-)

diff --git a/.last-branch b/.last-branch
index eb2cded..6ced2c8 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260120-04-autotask-deletedby-name-runlink-fix
+v20260120-05-autotask-indent-fix
diff --git a/containers/backupchecks/src/backend/app/main/routes_inbox.py b/containers/backupchecks/src/backend/app/main/routes_inbox.py
index 9998f84..d9bed53 100644
--- a/containers/backupchecks/src/backend/app/main/routes_inbox.py
+++ b/containers/backupchecks/src/backend/app/main/routes_inbox.py
@@ -295,7 +295,7 @@ def inbox_message_approve(message_id: int):
     if hasattr(run, 'storage_free_percent') and hasattr(msg, 'storage_free_percent'):
         run.storage_free_percent = msg.storage_free_percent
     db.session.add(run)
-    db.session.flush()
+        db.session.flush()
     try:
         link_open_internal_tickets_to_run(run=run, job=job)
     except Exception:
@@ -443,7 +443,7 @@ def inbox_message_approve_vspc_companies(message_id: int):
                 auto_approve=True,
             )
             db.session.add(job)
-            db.session.flush()
+        db.session.flush()
 
     # Commit any mapping updates so they are visible immediately in the UI.
     try:
@@ -513,7 +513,7 @@ def inbox_message_approve_vspc_companies(message_id: int):
                 auto_approve=True,
             )
             db.session.add(job)
-            db.session.flush()
+        db.session.flush()
 
         if not first_job:
             first_job = job
@@ -543,7 +543,7 @@ def inbox_message_approve_vspc_companies(message_id: int):
                 run.remark = getattr(msg, "overall_message", None)
 
             db.session.add(run)
-            db.session.flush()
+        db.session.flush()
             try:
                         link_open_internal_tickets_to_run(run=run, job=job)
             except Exception:
@@ -553,12 +553,12 @@ def inbox_message_approve_vspc_companies(message_id: int):
                 link_open_internal_tickets_to_run(run=run, job=job)
         except Exception:
                 pass
-    db.session.flush()
+        db.session.flush()
     try:
         link_open_internal_tickets_to_run(run=run, job=job)
     except Exception:
         pass
-            db.session.flush()
+        db.session.flush()
             created_runs.append(run)
 
         # Persist objects for reporting (idempotent upsert; safe to repeat).
@@ -704,7 +704,7 @@ def inbox_message_approve_vspc_companies(message_id: int):
                         if hasattr(run2, "remark"):
                             run2.remark = getattr(other, "overall_message", None)
                         db.session.add(run2)
-            db.session.flush()
+        db.session.flush()
             try:
                         link_open_internal_tickets_to_run(run=run2, job=job)
             except Exception:
@@ -714,12 +714,12 @@ def inbox_message_approve_vspc_companies(message_id: int):
                 link_open_internal_tickets_to_run(run=run2, job=job)
         except Exception:
                 pass
-    db.session.flush()
+        db.session.flush()
     try:
         link_open_internal_tickets_to_run(run=run2, job=job)
     except Exception:
         pass
-                        db.session.flush()
+        db.session.flush()
 
                     # Persist objects per company
                     try:
@@ -1085,7 +1085,7 @@ def inbox_reparse_all():
                                         run.storage_free_percent = msg.storage_free_percent
 
                                     db.session.add(run)
-            db.session.flush()
+        db.session.flush()
             try:
                         link_open_internal_tickets_to_run(run=run, job=job)
             except Exception:
@@ -1095,12 +1095,12 @@ def inbox_reparse_all():
                 link_open_internal_tickets_to_run(run=run, job=job)
         except Exception:
                 pass
-    db.session.flush()
+        db.session.flush()
     try:
         link_open_internal_tickets_to_run(run=run, job=job)
     except Exception:
         pass
-                                    db.session.flush()
+        db.session.flush()
                                     auto_approved_runs.append((job.customer_id, job.id, run.id, msg.id))
                                     created_any = True
 
@@ -1160,7 +1160,7 @@ def inbox_reparse_all():
                                 run.storage_free_percent = msg.storage_free_percent
 
                             db.session.add(run)
-            db.session.flush()
+        db.session.flush()
             try:
                         link_open_internal_tickets_to_run(run=run, job=job)
             except Exception:
@@ -1170,7 +1170,7 @@ def inbox_reparse_all():
                 link_open_internal_tickets_to_run(run=run, job=job)
         except Exception:
                 pass
-    db.session.flush()
+        db.session.flush()
     try:
         link_open_internal_tickets_to_run(run=run, job=job)
     except Exception:
@@ -1274,7 +1274,7 @@ def inbox_reparse_all():
                         run.storage_free_percent = msg.storage_free_percent
 
                     db.session.add(run)
-            db.session.flush()
+        db.session.flush()
             try:
                         link_open_internal_tickets_to_run(run=run, job=job)
             except Exception:
@@ -1284,12 +1284,12 @@ def inbox_reparse_all():
                 link_open_internal_tickets_to_run(run=run, job=job)
         except Exception:
                 pass
-    db.session.flush()
+        db.session.flush()
     try:
         link_open_internal_tickets_to_run(run=run, job=job)
     except Exception:
         pass
-                    db.session.flush()
+        db.session.flush()
                     auto_approved_runs.append((job.customer_id, job.id, run.id, msg.id))
 
                     msg.job_id = job.id
@@ -1368,4 +1368,4 @@ def inbox_reparse_all():
             "info",
         )
 
-    return redirect(url_for("main.inbox"))
+    return redirect(url_for("main.inbox"))
\ No newline at end of file
diff --git a/docs/changelog.md b/docs/changelog.md
index 20f9b5a..68e860a 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -394,6 +394,12 @@ Changes:
 - Updated Run Checks to display “Deleted by: <First name> <Last name>” with resource ID as fallback.
 - Restored legacy behavior by linking newly created job runs to any open internal tickets (TicketJobRun inherit) during mail import.
 
+## v20260120-05-autotask-indent-fix
+
+- Fixed an IndentationError in routes_inbox.py that prevented Gunicorn from starting.
+- Corrected the indentation of db.session.flush() to restore valid Python syntax.
+- No functional or logical changes were made.
+
 ***
 
 ## v0.1.21

From 899863a0de76e2a8ff1234956247cc004f3ca8e5 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Tue, 20 Jan 2026 10:44:53 +0100
Subject: [PATCH 57/63] Auto-commit local changes before build (2026-01-20
 10:44:53)

---
 .last-branch                                  |   2 +-
 .../src/backend/app/main/routes_inbox.py      | 102 +++++-------------
 docs/changelog.md                             |   8 ++
 3 files changed, 36 insertions(+), 76 deletions(-)

diff --git a/.last-branch b/.last-branch
index 6ced2c8..1bd40ee 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260120-05-autotask-indent-fix
+v20260120-06-routes-inbox-indent-fix
diff --git a/containers/backupchecks/src/backend/app/main/routes_inbox.py b/containers/backupchecks/src/backend/app/main/routes_inbox.py
index d9bed53..c558717 100644
--- a/containers/backupchecks/src/backend/app/main/routes_inbox.py
+++ b/containers/backupchecks/src/backend/app/main/routes_inbox.py
@@ -295,7 +295,7 @@ def inbox_message_approve(message_id: int):
     if hasattr(run, 'storage_free_percent') and hasattr(msg, 'storage_free_percent'):
         run.storage_free_percent = msg.storage_free_percent
     db.session.add(run)
-        db.session.flush()
+    db.session.flush()
     try:
         link_open_internal_tickets_to_run(run=run, job=job)
     except Exception:
@@ -529,6 +529,7 @@ def inbox_message_approve_vspc_companies(message_id: int):
 
         # De-duplicate: do not create multiple runs for the same (mail_message_id, job_id).
         run = JobRun.query.filter(JobRun.job_id == job.id, JobRun.mail_message_id == msg.id).first()
+        created = False
         if run:
             skipped_existing += 1
         else:
@@ -541,24 +542,17 @@ def inbox_message_approve_vspc_companies(message_id: int):
             )
             if hasattr(run, "remark"):
                 run.remark = getattr(msg, "overall_message", None)
-
             db.session.add(run)
-        db.session.flush()
-            try:
-                        link_open_internal_tickets_to_run(run=run, job=job)
-            except Exception:
-                        pass
+            created = True
+
+        # Ensure we have IDs before linking tickets or persisting objects.
         db.session.flush()
         try:
-                link_open_internal_tickets_to_run(run=run, job=job)
+            link_open_internal_tickets_to_run(run=run, job=job)
         except Exception:
-                pass
-        db.session.flush()
-    try:
-        link_open_internal_tickets_to_run(run=run, job=job)
-    except Exception:
-        pass
-        db.session.flush()
+            pass
+
+        if created:
             created_runs.append(run)
 
         # Persist objects for reporting (idempotent upsert; safe to repeat).
@@ -704,22 +698,12 @@ def inbox_message_approve_vspc_companies(message_id: int):
                         if hasattr(run2, "remark"):
                             run2.remark = getattr(other, "overall_message", None)
                         db.session.add(run2)
-        db.session.flush()
-            try:
-                        link_open_internal_tickets_to_run(run=run2, job=job)
-            except Exception:
+
+                    db.session.flush()
+                    try:
+                        link_open_internal_tickets_to_run(run=run2, job=job2)
+                    except Exception:
                         pass
-        db.session.flush()
-        try:
-                link_open_internal_tickets_to_run(run=run2, job=job)
-        except Exception:
-                pass
-        db.session.flush()
-    try:
-        link_open_internal_tickets_to_run(run=run2, job=job)
-    except Exception:
-        pass
-        db.session.flush()
 
                     # Persist objects per company
                     try:
@@ -1085,22 +1069,12 @@ def inbox_reparse_all():
                                         run.storage_free_percent = msg.storage_free_percent
 
                                     db.session.add(run)
-        db.session.flush()
-            try:
-                        link_open_internal_tickets_to_run(run=run, job=job)
-            except Exception:
-                        pass
-        db.session.flush()
-        try:
-                link_open_internal_tickets_to_run(run=run, job=job)
-        except Exception:
-                pass
-        db.session.flush()
-    try:
-        link_open_internal_tickets_to_run(run=run, job=job)
-    except Exception:
-        pass
-        db.session.flush()
+
+                                    db.session.flush()
+                                    try:
+                                        link_open_internal_tickets_to_run(run=run, job=job)
+                                    except Exception:
+                                        pass
                                     auto_approved_runs.append((job.customer_id, job.id, run.id, msg.id))
                                     created_any = True
 
@@ -1160,22 +1134,11 @@ def inbox_reparse_all():
                                 run.storage_free_percent = msg.storage_free_percent
 
                             db.session.add(run)
-        db.session.flush()
-            try:
-                        link_open_internal_tickets_to_run(run=run, job=job)
-            except Exception:
-                        pass
-        db.session.flush()
-        try:
-                link_open_internal_tickets_to_run(run=run, job=job)
-        except Exception:
-                pass
-        db.session.flush()
-    try:
-        link_open_internal_tickets_to_run(run=run, job=job)
-    except Exception:
-        pass
                             db.session.flush()  # ensure run.id is available
+                            try:
+                                link_open_internal_tickets_to_run(run=run, job=job)
+                            except Exception:
+                                pass
                             auto_approved_runs.append((job.customer_id, job.id, run.id, msg.id))
 
                             msg.job_id = job.id
@@ -1274,22 +1237,11 @@ def inbox_reparse_all():
                         run.storage_free_percent = msg.storage_free_percent
 
                     db.session.add(run)
-        db.session.flush()
-            try:
+                    db.session.flush()
+                    try:
                         link_open_internal_tickets_to_run(run=run, job=job)
-            except Exception:
+                    except Exception:
                         pass
-        db.session.flush()
-        try:
-                link_open_internal_tickets_to_run(run=run, job=job)
-        except Exception:
-                pass
-        db.session.flush()
-    try:
-        link_open_internal_tickets_to_run(run=run, job=job)
-    except Exception:
-        pass
-        db.session.flush()
                     auto_approved_runs.append((job.customer_id, job.id, run.id, msg.id))
 
                     msg.job_id = job.id
diff --git a/docs/changelog.md b/docs/changelog.md
index 68e860a..21ced4f 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -400,6 +400,14 @@ Changes:
 - Corrected the indentation of db.session.flush() to restore valid Python syntax.
 - No functional or logical changes were made.
 
+## v20260120-06-routes-inbox-indent-fix
+
+### Changes:
+- Fixed multiple indentation and syntax errors in routes_inbox.py.
+- Corrected misaligned db.session.flush() calls to ensure proper transaction handling.
+- Repaired indentation of link_open_internal_tickets_to_run logic to prevent runtime exceptions.
+- Restored application startup stability by resolving Python IndentationError issues.
+
 ***
 
 ## v0.1.21

From fc0cf1ef969d47322c08edeed3cba35fbc71db1d Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Tue, 20 Jan 2026 12:52:16 +0100
Subject: [PATCH 58/63] Auto-commit local changes before build (2026-01-20
 12:52:16)

---
 .last-branch                                  |  2 +-
 .../src/backend/app/main/routes_run_checks.py | 27 ++++++++++++++++---
 docs/changelog.md                             | 14 ++++++++++
 3 files changed, 39 insertions(+), 4 deletions(-)

diff --git a/.last-branch b/.last-branch
index 1bd40ee..882b180 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260120-06-routes-inbox-indent-fix
+v20260120-07-autotask-psa-resolution-handling
diff --git a/containers/backupchecks/src/backend/app/main/routes_run_checks.py b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
index ce3acb8..3fd2370 100644
--- a/containers/backupchecks/src/backend/app/main/routes_run_checks.py
+++ b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
@@ -115,7 +115,7 @@ def _resolve_internal_ticket_for_job(
 
     if ticket.resolved_at is None:
         ticket.resolved_at = now
-        if getattr(ticket, "resolved_origin", None) is None:
+        if not (getattr(ticket, "resolved_origin", None) or "").strip():
             ticket.resolved_origin = origin
 
     # Resolve all still-open scopes.
@@ -420,12 +420,33 @@ def _poll_autotask_ticket_states_for_runs(*, run_ids: list[int]) -> None:
         )
 
         # If terminal in PSA: resolve internally.
-        if internal_ticket is not None and status_int in AUTOTASK_TERMINAL_STATUS_IDS:
+        resolved_at = None
+        try:
+            if isinstance(t, dict):
+                resolved_at_raw = t.get("resolvedDateTime") or t.get("completedDate") or t.get("completedDateTime")
+            else:
+                resolved_at_raw = None
+            if resolved_at_raw:
+                s = str(resolved_at_raw).replace("Z", "+00:00")
+                resolved_at = datetime.fromisoformat(s)
+                if resolved_at.tzinfo is not None:
+                    resolved_at = resolved_at.astimezone(timezone.utc).replace(tzinfo=None)
+        except Exception:
+            resolved_at = None
+
+        is_terminal = False
+        if status_int in AUTOTASK_TERMINAL_STATUS_IDS:
+            is_terminal = True
+        if resolved_at is not None:
+            is_terminal = True
+
+        if internal_ticket is not None and is_terminal:
             _resolve_internal_ticket_for_job(
                 ticket=internal_ticket,
                 job=job,
                 run_ids=[int(x.id) for x in runs_for_ticket if getattr(x, "id", None)],
-                now=now,
+                now=resolved_at or now,
+                origin="Resolved by PSA",
             )
 
     try:
diff --git a/docs/changelog.md b/docs/changelog.md
index 21ced4f..fe83e04 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -408,6 +408,20 @@ Changes:
 - Repaired indentation of link_open_internal_tickets_to_run logic to prevent runtime exceptions.
 - Restored application startup stability by resolving Python IndentationError issues.
 
+## v20260120-07-autotask-psa-resolution-handling
+
+- Added support for linking existing Autotask tickets (Phase 2.2) using Autotask REST queries.
+- Implemented ticket listing by company with exclusion of terminal tickets (status != Complete).
+- Added search support for existing tickets by exact ticketNumber and by title (contains).
+- Implemented authoritative validation of selected Autotask tickets via GET /Tickets/{id}.
+- Defined terminal ticket detection based on:
+  - status == Complete (5)
+  - OR completedDate is set
+  - OR resolvedDateTime is set.
+- Ensured terminal Autotask tickets automatically resolve the corresponding internal Backupchecks ticket.
+- Preserved legacy internal Ticket and TicketJobRun creation/linking so Tickets overview, Tickets/Remarks, and Job Details continue to function identically to manually linked tickets.
+- Ensured resolution timestamps are derived from Autotask (resolvedDateTime / completedDate) instead of using current time.
+
 ***
 
 ## v0.1.21

From 92c67805e5a7cfe0230444612baa6503fb8cb942 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Tue, 20 Jan 2026 13:10:45 +0100
Subject: [PATCH 59/63] Auto-commit local changes before build (2026-01-20
 13:10:45)

---
 .last-branch                                  |   2 +-
 .../app/integrations/autotask/client.py       |  56 ++++
 .../src/backend/app/main/routes_run_checks.py | 244 +++++++++++++++++-
 .../src/templates/main/run_checks.html        | 158 +++++++++++-
 docs/changelog.md                             |  12 +
 5 files changed, 467 insertions(+), 5 deletions(-)

diff --git a/.last-branch b/.last-branch
index 882b180..9671641 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260120-07-autotask-psa-resolution-handling
+v20260120-08-runchecks-link-existing-autotask-ticket
diff --git a/containers/backupchecks/src/backend/app/integrations/autotask/client.py b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
index bc8b963..e190716 100644
--- a/containers/backupchecks/src/backend/app/integrations/autotask/client.py
+++ b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
@@ -601,3 +601,59 @@ class AutotaskClient:
 
         data = self._request("POST", "Tickets/query", json_body={"filter": flt})
         return self._as_items_list(data)
+
+    def query_tickets_for_company(
+        self,
+        company_id: int,
+        *,
+        search: str = "",
+        exclude_status_ids: Optional[List[int]] = None,
+        limit: int = 50,
+    ) -> List[Dict[str, Any]]:
+        """Query Tickets for a specific company, optionally searching by ticket number or title.
+
+        Uses POST /Tickets/query.
+
+        Note:
+        - Autotask query operators vary by tenant; we use common operators (eq, contains).
+        - If the query fails due to operator support, callers should fall back to get_ticket(id).
+        """
+
+        try:
+            cid = int(company_id)
+        except Exception:
+            cid = 0
+        if cid <= 0:
+            return []
+
+        flt: List[Dict[str, Any]] = [
+            {"op": "eq", "field": "companyID", "value": cid},
+        ]
+
+        ex: List[int] = []
+        for x in exclude_status_ids or []:
+            try:
+                v = int(x)
+            except Exception:
+                continue
+            if v > 0:
+                ex.append(v)
+        if ex:
+            flt.append({"op": "notIn", "field": "status", "value": ex})
+
+        q = (search or "").strip()
+        if q:
+            # Ticket numbers in Autotask are typically like T20260119.0004
+            if q.upper().startswith("T") and any(ch.isdigit() for ch in q):
+                flt.append({"op": "eq", "field": "ticketNumber", "value": q.strip()})
+            else:
+                # Broad search on title
+                flt.append({"op": "contains", "field": "title", "value": q})
+
+        data = self._request("POST", "Tickets/query", json_body={"filter": flt})
+        items = self._as_items_list(data)
+
+        # Respect limit if tenant returns more.
+        if limit and isinstance(limit, int) and limit > 0:
+            return items[: int(limit)]
+        return items
diff --git a/containers/backupchecks/src/backend/app/main/routes_run_checks.py b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
index 3fd2370..1c4334e 100644
--- a/containers/backupchecks/src/backend/app/main/routes_run_checks.py
+++ b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
@@ -427,8 +427,8 @@ def _poll_autotask_ticket_states_for_runs(*, run_ids: list[int]) -> None:
             else:
                 resolved_at_raw = None
             if resolved_at_raw:
-                s = str(resolved_at_raw).replace("Z", "+00:00")
-                resolved_at = datetime.fromisoformat(s)
+                s_dt = str(resolved_at_raw).replace("Z", "+00:00")
+                resolved_at = datetime.fromisoformat(s_dt)
                 if resolved_at.tzinfo is not None:
                     resolved_at = resolved_at.astimezone(timezone.utc).replace(tzinfo=None)
         except Exception:
@@ -446,7 +446,7 @@ def _poll_autotask_ticket_states_for_runs(*, run_ids: list[int]) -> None:
                 job=job,
                 run_ids=[int(x.id) for x in runs_for_ticket if getattr(x, "id", None)],
                 now=resolved_at or now,
-                origin="Resolved by PSA",
+                origin="psa",
             )
 
     try:
@@ -1567,6 +1567,244 @@ def api_run_checks_create_autotask_ticket():
     )
 
 
+
+
+@main_bp.get("/api/run-checks/autotask-existing-tickets")
+@login_required
+@roles_required("admin", "operator")
+def api_run_checks_autotask_existing_tickets():
+    """List open (non-terminal) Autotask tickets for the selected run's customer.
+
+    Phase 2.2: used by the Run Checks modal to link an existing PSA ticket.
+    """
+
+    try:
+        run_id = int(request.args.get("run_id") or 0)
+    except Exception:
+        run_id = 0
+
+    q = (request.args.get("q") or "").strip()
+
+    if run_id <= 0:
+        return jsonify({"status": "error", "message": "Invalid parameters."}), 400
+
+    run = JobRun.query.get(run_id)
+    if not run:
+        return jsonify({"status": "error", "message": "Run not found."}), 404
+
+    job = Job.query.get(run.job_id)
+    if not job:
+        return jsonify({"status": "error", "message": "Job not found."}), 404
+
+    customer = Customer.query.get(job.customer_id) if getattr(job, "customer_id", None) else None
+    if not customer:
+        return jsonify({"status": "error", "message": "Customer not found."}), 404
+
+    if not getattr(customer, "autotask_company_id", None):
+        return jsonify({"status": "error", "message": "Customer has no Autotask company mapping."}), 400
+
+    if (getattr(customer, "autotask_mapping_status", None) or "").strip().lower() not in ("ok", "renamed"):
+        return jsonify({"status": "error", "message": "Autotask company mapping is not valid."}), 400
+
+    settings = _get_or_create_settings()
+
+    # Map status ID -> label from cached settings (kept in sync by Settings page).
+    status_map = {}
+    try:
+        import json as _json
+
+        raw = getattr(settings, "autotask_cached_ticket_statuses_json", None)
+        if raw:
+            for x in (_json.loads(raw) or []):
+                if isinstance(x, dict) and "value" in x:
+                    status_map[str(x.get("value"))] = str(x.get("label") or "")
+    except Exception:
+        status_map = {}
+
+    try:
+        client = _build_autotask_client_from_settings()
+
+        # Ensure we have a status map; if empty, fetch and cache once.
+        if not status_map:
+            try:
+                import json as _json
+
+                statuses = client.get_ticket_statuses()
+                settings.autotask_cached_ticket_statuses_json = _json.dumps(statuses)
+                settings.autotask_reference_last_sync_at = datetime.utcnow()
+                db.session.commit()
+                for x in (statuses or []):
+                    if isinstance(x, dict) and "value" in x:
+                        status_map[str(x.get("value"))] = str(x.get("label") or "")
+            except Exception:
+                # Best-effort; list will still work without labels.
+                pass
+
+        tickets = client.query_tickets_for_company(
+            int(customer.autotask_company_id),
+            search=q,
+            exclude_status_ids=sorted(AUTOTASK_TERMINAL_STATUS_IDS),
+            limit=75,
+        )
+    except Exception as exc:
+        return jsonify({"status": "error", "message": f"Autotask ticket lookup failed: {exc}"}), 400
+
+    items = []
+    for t in tickets or []:
+        if not isinstance(t, dict):
+            continue
+        tid = t.get("id")
+        tnum = (t.get("ticketNumber") or t.get("number") or "")
+        title = (t.get("title") or "")
+        st = t.get("status")
+        try:
+            st_int = int(st) if st is not None else None
+        except Exception:
+            st_int = None
+        st_label = status_map.get(str(st_int)) if st_int is not None else ""
+        items.append(
+            {
+                "id": tid,
+                "ticketNumber": str(tnum or ""),
+                "title": str(title or ""),
+                "status": st_int,
+                "statusLabel": st_label or "",
+            }
+        )
+
+    # Sort: newest-ish first. Autotask query ordering isn't guaranteed, so we provide a stable sort.
+    items.sort(key=lambda x: (x.get("ticketNumber") or ""), reverse=True)
+
+    return jsonify({"status": "ok", "items": items})
+
+
+@main_bp.post("/api/run-checks/autotask-link-existing-ticket")
+@login_required
+@roles_required("admin", "operator")
+def api_run_checks_autotask_link_existing_ticket():
+    """Link an existing Autotask ticket to the selected run (and propagate to all active runs of the job).
+
+    Phase 2.2: used by the Run Checks modal.
+    """
+
+    data = request.get_json(silent=True) or {}
+
+    try:
+        run_id = int(data.get("run_id") or 0)
+    except Exception:
+        run_id = 0
+
+    try:
+        ticket_id = int(data.get("ticket_id") or 0)
+    except Exception:
+        ticket_id = 0
+
+    if run_id <= 0 or ticket_id <= 0:
+        return jsonify({"status": "error", "message": "Invalid parameters."}), 400
+
+    run = JobRun.query.get(run_id)
+    if not run:
+        return jsonify({"status": "error", "message": "Run not found."}), 404
+
+    # Do not overwrite an existing link unless the current one is resolved/deleted.
+    if getattr(run, "autotask_ticket_id", None):
+        return jsonify({"status": "error", "message": "Run already has an Autotask ticket linked."}), 400
+
+    job = Job.query.get(run.job_id)
+    if not job:
+        return jsonify({"status": "error", "message": "Job not found."}), 404
+
+    customer = Customer.query.get(job.customer_id) if getattr(job, "customer_id", None) else None
+    if not customer:
+        return jsonify({"status": "error", "message": "Customer not found."}), 404
+
+    if not getattr(customer, "autotask_company_id", None):
+        return jsonify({"status": "error", "message": "Customer has no Autotask company mapping."}), 400
+
+    if (getattr(customer, "autotask_mapping_status", None) or "").strip().lower() not in ("ok", "renamed"):
+        return jsonify({"status": "error", "message": "Autotask company mapping is not valid."}), 400
+
+    try:
+        client = _build_autotask_client_from_settings()
+        t = client.get_ticket(ticket_id)
+    except Exception as exc:
+        return jsonify({"status": "error", "message": f"Autotask ticket retrieval failed: {exc}"}), 400
+
+    if not isinstance(t, dict):
+        return jsonify({"status": "error", "message": "Autotask did not return a ticket object."}), 400
+
+    # Enforce company scope.
+    try:
+        t_company = int(t.get("companyID") or 0)
+    except Exception:
+        t_company = 0
+
+    if t_company != int(customer.autotask_company_id):
+        return jsonify({"status": "error", "message": "Selected ticket does not belong to the mapped Autotask company."}), 400
+
+    tnum = (t.get("ticketNumber") or t.get("number") or "")
+    tnum = str(tnum or "").strip()
+    if not tnum:
+        return jsonify({"status": "error", "message": "Autotask ticket does not have a ticket number."}), 400
+
+    # Block terminal tickets from being linked (Phase 2.2 only lists open tickets, but enforce server-side).
+    try:
+        st = int(t.get("status")) if t.get("status") is not None else 0
+    except Exception:
+        st = 0
+    if st in AUTOTASK_TERMINAL_STATUS_IDS:
+        return jsonify({"status": "error", "message": "Cannot link a terminal/completed Autotask ticket."}), 400
+
+    now = datetime.utcnow()
+
+    run.autotask_ticket_id = int(ticket_id)
+    run.autotask_ticket_number = tnum
+    run.autotask_ticket_created_at = now
+    run.autotask_ticket_created_by_user_id = current_user.id
+
+    # Propagate linkage to all active (unreviewed) runs of the same job.
+    active_runs = (
+        JobRun.query.filter(JobRun.job_id == job.id, JobRun.reviewed_at.is_(None)).order_by(JobRun.id.asc()).all()
+    )
+    run_ids = []
+    for rr in active_runs or []:
+        if getattr(rr, "id", None) is None:
+            continue
+        rr.autotask_ticket_id = int(ticket_id)
+        rr.autotask_ticket_number = tnum
+        if getattr(rr, "autotask_ticket_created_at", None) is None:
+            rr.autotask_ticket_created_at = now
+        if getattr(rr, "autotask_ticket_created_by_user_id", None) is None:
+            rr.autotask_ticket_created_by_user_id = current_user.id
+        run_ids.append(int(rr.id))
+
+    # Ensure internal Ticket + TicketJobRun linkage for legacy ticket behavior.
+    internal_ticket = None
+    try:
+        internal_ticket = _ensure_internal_ticket_for_autotask(
+            ticket_number=tnum,
+            job=job,
+            run_ids=run_ids,
+            now=now,
+            active_from_dt=now,
+        )
+    except Exception:
+        internal_ticket = None
+
+    try:
+        db.session.commit()
+    except Exception:
+        db.session.rollback()
+        return jsonify({"status": "error", "message": "Failed to persist Autotask ticket link."}), 500
+
+    return jsonify(
+        {
+            "status": "ok",
+            "ticket_id": int(ticket_id),
+            "ticket_number": tnum,
+            "internal_ticket_id": int(getattr(internal_ticket, "id", 0) or 0) if internal_ticket else 0,
+        }
+    )
 @main_bp.post("/api/run-checks/mark-reviewed")
 @login_required
 @roles_required("admin", "operator")
diff --git a/containers/backupchecks/src/templates/main/run_checks.html b/containers/backupchecks/src/templates/main/run_checks.html
index e05d738..7eada09 100644
--- a/containers/backupchecks/src/templates/main/run_checks.html
+++ b/containers/backupchecks/src/templates/main/run_checks.html
@@ -219,7 +219,10 @@
 	                          {% if autotask_enabled %}
 	                          <div class="d-flex align-items-center justify-content-between">
 	                            <div class="fw-semibold">Autotask ticket</div>
-	                            <button type="button" class="btn btn-sm btn-outline-primary" id="rcm_autotask_create">Create</button>
+	                            <div class="d-flex gap-2">
+								    <button type="button" class="btn btn-sm btn-outline-secondary" id="rcm_autotask_link_existing">Link existing</button>
+								    <button type="button" class="btn btn-sm btn-outline-primary" id="rcm_autotask_create">Create</button>
+								  </div>
 	                          </div>
 	                          <div class="mt-2 small" id="rcm_autotask_info"></div>
 	                          <div class="mt-2 small text-muted" id="rcm_autotask_status"></div>
@@ -292,6 +295,43 @@
   </div>
 </div>
 
+
+
+<div class="modal fade" id="autotaskLinkModal" tabindex="-1" aria-labelledby="autotaskLinkModalLabel" aria-hidden="true">
+  <div class="modal-dialog modal-lg modal-dialog-scrollable">
+    <div class="modal-content">
+      <div class="modal-header">
+        <h5 class="modal-title" id="autotaskLinkModalLabel">Link existing Autotask ticket</h5>
+        <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+      </div>
+      <div class="modal-body">
+        <div class="d-flex gap-2 mb-2">
+          <input type="text" class="form-control" id="atl_search" placeholder="Search by ticket number or title" />
+          <button type="button" class="btn btn-outline-secondary" id="atl_refresh">Refresh</button>
+        </div>
+        <div class="small text-muted mb-2" id="atl_status"></div>
+        <div class="table-responsive">
+          <table class="table table-sm table-hover align-middle">
+            <thead class="table-light">
+              <tr>
+                <th style="width: 1%;"></th>
+                <th>Ticket</th>
+                <th>Title</th>
+                <th>Status</th>
+              </tr>
+            </thead>
+            <tbody id="atl_tbody"></tbody>
+          </table>
+        </div>
+        <div class="text-muted" id="atl_empty" style="display:none;">No tickets found.</div>
+      </div>
+      <div class="modal-footer">
+        <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">Close</button>
+      </div>
+    </div>
+  </div>
+</div>
+
 <script>
   (function () {
     var table = document.getElementById('runChecksTable');
@@ -851,6 +891,7 @@ table.addEventListener('change', function (e) {
 
     function bindInlineCreateForms() {
       var btnAutotask = document.getElementById('rcm_autotask_create');
+      var btnAutotaskLink = document.getElementById('rcm_autotask_link_existing');
       var atInfo = document.getElementById('rcm_autotask_info');
       var atStatus = document.getElementById('rcm_autotask_status');
 
@@ -870,6 +911,7 @@ table.addEventListener('change', function (e) {
 
       function setDisabled(disabled) {
         if (btnAutotask) btnAutotask.disabled = disabled;
+        if (btnAutotaskLink) btnAutotaskLink.disabled = disabled;
         if (btnTicket) btnTicket.disabled = disabled;
         if (tCode) tCode.disabled = disabled;
         if (btnRemark) btnRemark.disabled = disabled;
@@ -915,6 +957,12 @@ table.addEventListener('change', function (e) {
           if (run && run.autotask_ticket_id && (isResolved || isDeleted)) btnAutotask.textContent = 'Create new';
           else btnAutotask.textContent = 'Create';
         }
+
+        if (btnAutotaskLink) {
+          var hasAtTicket = !!(run && run.autotask_ticket_id);
+          // Link existing is only meaningful when there is no PSA ticket linked to this run.
+          btnAutotaskLink.style.display = hasAtTicket ? 'none' : '';
+        }
       }
       window.__rcmRenderAutotaskInfo = renderAutotaskInfo;
 
@@ -963,6 +1011,114 @@ table.addEventListener('change', function (e) {
         });
       }
 
+      if (btnAutotaskLink) {
+        var linkModalEl = document.getElementById('autotaskLinkModal');
+        var linkModal = linkModalEl ? bootstrap.Modal.getOrCreateInstance(linkModalEl) : null;
+        var atlSearch = document.getElementById('atl_search');
+        var atlRefresh = document.getElementById('atl_refresh');
+        var atlStatus = document.getElementById('atl_status');
+        var atlTbody = document.getElementById('atl_tbody');
+        var atlEmpty = document.getElementById('atl_empty');
+
+        function renderAtlRows(items) {
+          if (!atlTbody) return;
+          atlTbody.innerHTML = '';
+          if (atlEmpty) atlEmpty.style.display = (items && items.length) ? 'none' : '';
+          (items || []).forEach(function (t) {
+            var tr = document.createElement('tr');
+            var tdBtn = document.createElement('td');
+            var btn = document.createElement('button');
+            btn.type = 'button';
+            btn.className = 'btn btn-sm btn-outline-primary';
+            btn.textContent = 'Link';
+            btn.addEventListener('click', function () {
+              if (!currentRunId) { alert('Select a run first.'); return; }
+              if (!confirm('Link ticket ' + (t.ticketNumber || '') + ' to this run?')) return;
+              if (atlStatus) atlStatus.textContent = 'Linking...';
+              apiJson('/api/run-checks/autotask-link-existing-ticket', {
+                method: 'POST',
+                body: JSON.stringify({run_id: currentRunId, ticket_id: t.id})
+              })
+              .then(function (j) {
+                if (!j || j.status !== 'ok') throw new Error((j && j.message) || 'Failed.');
+                if (atlStatus) atlStatus.textContent = '';
+                if (linkModal) linkModal.hide();
+
+                // Refresh modal data so UI reflects stored ticket linkage.
+                var keepRunId = currentRunId;
+                if (currentJobId) {
+                  return fetch('/api/run-checks/details?job_id=' + encodeURIComponent(currentJobId))
+                    .then(function (r) { return r.json(); })
+                    .then(function (payload) {
+                      currentPayload = payload;
+                      var idx = 0;
+                      var runs = (payload && payload.runs) || [];
+                      for (var i = 0; i < runs.length; i++) {
+                        if (String(runs[i].id) === String(keepRunId)) { idx = i; break; }
+                      }
+                      renderRun(payload, idx);
+                    });
+                }
+              })
+              .catch(function (e) {
+                if (atlStatus) atlStatus.textContent = e.message || 'Failed.';
+                else alert(e.message || 'Failed.');
+              });
+            });
+            tdBtn.appendChild(btn);
+
+            var tdNum = document.createElement('td');
+            tdNum.textContent = (t.ticketNumber || '');
+
+            var tdTitle = document.createElement('td');
+            tdTitle.textContent = (t.title || '');
+
+            var tdStatus = document.createElement('td');
+            tdStatus.textContent = (t.status_label || String(t.status || ''));
+
+            tr.appendChild(tdBtn);
+            tr.appendChild(tdNum);
+            tr.appendChild(tdTitle);
+            tr.appendChild(tdStatus);
+            atlTbody.appendChild(tr);
+          });
+        }
+
+        function loadExistingTickets() {
+          if (!currentRunId) { alert('Select a run first.'); return; }
+          var q = atlSearch ? (atlSearch.value || '').trim() : '';
+          if (atlStatus) atlStatus.textContent = 'Loading...';
+          fetch('/api/run-checks/autotask-existing-tickets?run_id=' + encodeURIComponent(currentRunId) + '&q=' + encodeURIComponent(q))
+            .then(function (r) { return r.json(); })
+            .then(function (j) {
+              if (!j || j.status !== 'ok') throw new Error((j && j.message) || 'Failed.');
+              if (atlStatus) atlStatus.textContent = '';
+              renderAtlRows(j.items || []);
+            })
+            .catch(function (e) {
+              if (atlStatus) atlStatus.textContent = e.message || 'Failed.';
+              renderAtlRows([]);
+            });
+        }
+
+        if (atlRefresh) {
+          atlRefresh.addEventListener('click', function () { loadExistingTickets(); });
+        }
+        if (atlSearch) {
+          atlSearch.addEventListener('keydown', function (ev) {
+            if (ev.key === 'Enter') { ev.preventDefault(); loadExistingTickets(); }
+          });
+        }
+
+        btnAutotaskLink.addEventListener('click', function () {
+          if (!currentRunId) { alert('Select a run first.'); return; }
+          if (atlStatus) atlStatus.textContent = '';
+          renderAtlRows([]);
+          if (linkModal) linkModal.show();
+          loadExistingTickets();
+        });
+      }
+
       if (btnAutotask) {
         btnAutotask.addEventListener('click', function () {
           if (!currentRunId) { alert('Select a run first.'); return; }
diff --git a/docs/changelog.md b/docs/changelog.md
index fe83e04..a075402 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -422,6 +422,18 @@ Changes:
 - Preserved legacy internal Ticket and TicketJobRun creation/linking so Tickets overview, Tickets/Remarks, and Job Details continue to function identically to manually linked tickets.
 - Ensured resolution timestamps are derived from Autotask (resolvedDateTime / completedDate) instead of using current time.
 
+## v20260120-08-runchecks-link-existing-autotask-ticket
+
+- Added Phase 2.2 “Link existing Autotask ticket” flow in Run Checks:
+  - New UI button “Link existing” next to “Create” in the Run Checks modal.
+  - Added modal popup with search + refresh and a selectable list of non-terminal tickets.
+- Added backend API endpoints:
+  - GET /api/run-checks/autotask-existing-tickets (list/search tickets for mapped company, excluding terminal statuses)
+  - POST /api/run-checks/autotask-link-existing-ticket (link selected ticket to run and create/update internal Ticket + TicketJobRun links)
+- Extended Autotask client with a ticket query helper to support listing/searching tickets for a company.
+- Improved internal ticket resolve handling:
+  - Do not overwrite resolved_origin when already set; keep “psa” origin when resolved by PSA.
+  
 ***
 
 ## v0.1.21

From ae1865dab312507f0265099ae3502b6d8ed52a62 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Tue, 20 Jan 2026 13:22:37 +0100
Subject: [PATCH 60/63] Auto-commit local changes before build (2026-01-20
 13:22:37)

---
 .last-branch                                  |  2 +-
 .../src/templates/main/run_checks.html        | 21 +++++++++++++++++++
 docs/changelog.md                             | 10 +++++++++
 3 files changed, 32 insertions(+), 1 deletion(-)

diff --git a/.last-branch b/.last-branch
index 9671641..d11047e 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260120-08-runchecks-link-existing-autotask-ticket
+v20260120-09-runchecks-modal-sequence-fix
diff --git a/containers/backupchecks/src/templates/main/run_checks.html b/containers/backupchecks/src/templates/main/run_checks.html
index 7eada09..fe1a50f 100644
--- a/containers/backupchecks/src/templates/main/run_checks.html
+++ b/containers/backupchecks/src/templates/main/run_checks.html
@@ -1014,12 +1014,27 @@ table.addEventListener('change', function (e) {
       if (btnAutotaskLink) {
         var linkModalEl = document.getElementById('autotaskLinkModal');
         var linkModal = linkModalEl ? bootstrap.Modal.getOrCreateInstance(linkModalEl) : null;
+        // Avoid stacked Bootstrap modals: temporarily hide the main Run Checks modal
+        // and re-open it when the Autotask link modal is closed.
+        var mainModalEl = document.getElementById('runChecksModal');
+        var mainModal = mainModalEl ? bootstrap.Modal.getOrCreateInstance(mainModalEl) : null;
+        var reopenMainAfterLinkModal = false;
         var atlSearch = document.getElementById('atl_search');
         var atlRefresh = document.getElementById('atl_refresh');
         var atlStatus = document.getElementById('atl_status');
         var atlTbody = document.getElementById('atl_tbody');
         var atlEmpty = document.getElementById('atl_empty');
 
+        if (linkModalEl) {
+          linkModalEl.addEventListener('hidden.bs.modal', function () {
+            if (reopenMainAfterLinkModal && mainModal) {
+              reopenMainAfterLinkModal = false;
+              // Re-open the main modal so the normal Run Checks workflow continues.
+              mainModal.show();
+            }
+          });
+        }
+
         function renderAtlRows(items) {
           if (!atlTbody) return;
           atlTbody.innerHTML = '';
@@ -1114,6 +1129,12 @@ table.addEventListener('change', function (e) {
           if (!currentRunId) { alert('Select a run first.'); return; }
           if (atlStatus) atlStatus.textContent = '';
           renderAtlRows([]);
+          // Show the existing Run Checks popup first, then switch to the Autotask popup.
+          // This prevents the main popup from breaking due to stacked modal backdrops.
+          if (mainModal) {
+            reopenMainAfterLinkModal = true;
+            mainModal.hide();
+          }
           if (linkModal) linkModal.show();
           loadExistingTickets();
         });
diff --git a/docs/changelog.md b/docs/changelog.md
index a075402..94a0181 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -434,6 +434,16 @@ Changes:
 - Improved internal ticket resolve handling:
   - Do not overwrite resolved_origin when already set; keep “psa” origin when resolved by PSA.
   
+## v20260120-09-runchecks-modal-sequence-fix
+
+- Fixed Run Checks popup behavior by preventing stacked Bootstrap modals.
+- Restored correct modal sequence:
+  - The standard Run Checks modal opens first as before.
+  - The Autotask popup is opened only after explicitly selecting an Autotask action.
+- Ensured the Run Checks modal is temporarily hidden when the Autotask popup opens.
+- Automatically reopens the Run Checks modal when the Autotask popup is closed.
+- Prevented broken backdrops, focus loss, and non-responsive popups caused by multiple active modals.
+
 ***
 
 ## v0.1.21

From 67fb063267dfa6098652b3f75da5a77223e8f1df Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Tue, 20 Jan 2026 13:32:55 +0100
Subject: [PATCH 61/63] Auto-commit local changes before build (2026-01-20
 13:32:55)

---
 .last-branch                                  |  2 +-
 .../src/templates/main/run_checks.html        | 70 ++++++++++++++-----
 docs/changelog.md                             |  7 ++
 3 files changed, 61 insertions(+), 18 deletions(-)

diff --git a/.last-branch b/.last-branch
index d11047e..7313130 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260120-09-runchecks-modal-sequence-fix
+v20260120-10-runchecks-bootstrap-compat-fix
diff --git a/containers/backupchecks/src/templates/main/run_checks.html b/containers/backupchecks/src/templates/main/run_checks.html
index fe1a50f..f1a713d 100644
--- a/containers/backupchecks/src/templates/main/run_checks.html
+++ b/containers/backupchecks/src/templates/main/run_checks.html
@@ -1013,11 +1013,9 @@ table.addEventListener('change', function (e) {
 
       if (btnAutotaskLink) {
         var linkModalEl = document.getElementById('autotaskLinkModal');
-        var linkModal = linkModalEl ? bootstrap.Modal.getOrCreateInstance(linkModalEl) : null;
         // Avoid stacked Bootstrap modals: temporarily hide the main Run Checks modal
         // and re-open it when the Autotask link modal is closed.
         var mainModalEl = document.getElementById('runChecksModal');
-        var mainModal = mainModalEl ? bootstrap.Modal.getOrCreateInstance(mainModalEl) : null;
         var reopenMainAfterLinkModal = false;
         var atlSearch = document.getElementById('atl_search');
         var atlRefresh = document.getElementById('atl_refresh');
@@ -1025,15 +1023,13 @@ table.addEventListener('change', function (e) {
         var atlTbody = document.getElementById('atl_tbody');
         var atlEmpty = document.getElementById('atl_empty');
 
-        if (linkModalEl) {
-          linkModalEl.addEventListener('hidden.bs.modal', function () {
-            if (reopenMainAfterLinkModal && mainModal) {
-              reopenMainAfterLinkModal = false;
-              // Re-open the main modal so the normal Run Checks workflow continues.
-              mainModal.show();
-            }
-          });
-        }
+        _modalOnHidden(linkModalEl, function () {
+          if (reopenMainAfterLinkModal && mainModalEl) {
+            reopenMainAfterLinkModal = false;
+            // Re-open the main modal so the normal Run Checks workflow continues.
+            _modalShow(mainModalEl);
+          }
+        });
 
         function renderAtlRows(items) {
           if (!atlTbody) return;
@@ -1057,7 +1053,7 @@ table.addEventListener('change', function (e) {
               .then(function (j) {
                 if (!j || j.status !== 'ok') throw new Error((j && j.message) || 'Failed.');
                 if (atlStatus) atlStatus.textContent = '';
-                if (linkModal) linkModal.hide();
+                _modalHide(linkModalEl);
 
                 // Refresh modal data so UI reflects stored ticket linkage.
                 var keepRunId = currentRunId;
@@ -1131,11 +1127,11 @@ table.addEventListener('change', function (e) {
           renderAtlRows([]);
           // Show the existing Run Checks popup first, then switch to the Autotask popup.
           // This prevents the main popup from breaking due to stacked modal backdrops.
-          if (mainModal) {
+          if (mainModalEl) {
             reopenMainAfterLinkModal = true;
-            mainModal.hide();
+            _modalHide(mainModalEl);
           }
-          if (linkModal) linkModal.show();
+          _modalShow(linkModalEl);
           loadExistingTickets();
         });
       }
@@ -1315,6 +1311,47 @@ table.addEventListener('change', function (e) {
       }
     }
 
+    // Modal helpers
+    // The global "bootstrap" namespace is not always available (e.g. Bootstrap 4 + jQuery).
+    // Use a small compatibility layer so Run Checks modals keep working.
+    function _modalShow(modalEl) {
+      if (!modalEl) return;
+      if (window.bootstrap && window.bootstrap.Modal && window.bootstrap.Modal.getOrCreateInstance) {
+        window.bootstrap.Modal.getOrCreateInstance(modalEl).show();
+        return;
+      }
+      if (window.jQuery) {
+        window.jQuery(modalEl).modal('show');
+        return;
+      }
+      // Last resort: basic display (should not normally be needed)
+      modalEl.classList.add('show');
+      modalEl.style.display = 'block';
+    }
+
+    function _modalHide(modalEl) {
+      if (!modalEl) return;
+      if (window.bootstrap && window.bootstrap.Modal && window.bootstrap.Modal.getOrCreateInstance) {
+        window.bootstrap.Modal.getOrCreateInstance(modalEl).hide();
+        return;
+      }
+      if (window.jQuery) {
+        window.jQuery(modalEl).modal('hide');
+        return;
+      }
+      modalEl.classList.remove('show');
+      modalEl.style.display = 'none';
+    }
+
+    function _modalOnHidden(modalEl, handler) {
+      if (!modalEl || !handler) return;
+      if (window.jQuery) {
+        window.jQuery(modalEl).one('hidden.bs.modal', handler);
+        return;
+      }
+      modalEl.addEventListener('hidden.bs.modal', handler);
+    }
+
     function openJobModal(jobId) {
       if (!jobId) return;
       currentJobId = jobId;
@@ -1323,8 +1360,7 @@ table.addEventListener('change', function (e) {
       if (btnMarkSuccessOverride) btnMarkSuccessOverride.disabled = true;
 
       var modalEl = document.getElementById('runChecksModal');
-      var modal = bootstrap.Modal.getOrCreateInstance(modalEl);
-      modal.show();
+      _modalShow(modalEl);
 
       document.getElementById('rcm_loading').style.display = 'block';
       document.getElementById('rcm_content').style.display = 'none';
diff --git a/docs/changelog.md b/docs/changelog.md
index 94a0181..7485cfe 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -444,6 +444,13 @@ Changes:
 - Automatically reopens the Run Checks modal when the Autotask popup is closed.
 - Prevented broken backdrops, focus loss, and non-responsive popups caused by multiple active modals.
 
+## v20260120-10-runchecks-bootstrap-compat-fix
+
+- Fixed Run Checks page crash caused by referencing the Bootstrap 5 global "bootstrap" object when it is not available.
+- Added Bootstrap 4/5 compatible modal helpers (show/hide/hidden event) using jQuery modal API when needed.
+- Updated Run Checks modal opening and Autotask link modal flow to use the compatibility helpers.
+- Restored normal Run Checks popup behavior (click handlers execute again because the page no longer errors on load).
+
 ***
 
 ## v0.1.21

From 3400af58d7e8c984602c7bd834c6075b4a2020c6 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Tue, 20 Jan 2026 13:42:54 +0100
Subject: [PATCH 62/63] Auto-commit local changes before build (2026-01-20
 13:42:54)

---
 .last-branch                                               | 2 +-
 containers/backupchecks/src/templates/main/run_checks.html | 2 +-
 docs/changelog.md                                          | 6 ++++++
 3 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/.last-branch b/.last-branch
index 7313130..5b19c90 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260120-10-runchecks-bootstrap-compat-fix
+v20260120-11-runchecks-autotask-status-label
diff --git a/containers/backupchecks/src/templates/main/run_checks.html b/containers/backupchecks/src/templates/main/run_checks.html
index f1a713d..d47509f 100644
--- a/containers/backupchecks/src/templates/main/run_checks.html
+++ b/containers/backupchecks/src/templates/main/run_checks.html
@@ -1085,7 +1085,7 @@ table.addEventListener('change', function (e) {
             tdTitle.textContent = (t.title || '');
 
             var tdStatus = document.createElement('td');
-            tdStatus.textContent = (t.status_label || String(t.status || ''));
+            tdStatus.textContent = (t.statusLabel || t.status_label || String(t.status || ''));
 
             tr.appendChild(tdBtn);
             tr.appendChild(tdNum);
diff --git a/docs/changelog.md b/docs/changelog.md
index 7485cfe..daa005a 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -451,6 +451,12 @@ Changes:
 - Updated Run Checks modal opening and Autotask link modal flow to use the compatibility helpers.
 - Restored normal Run Checks popup behavior (click handlers execute again because the page no longer errors on load).
 
+## v20260120-11-runchecks-autotask-status-label
+
+- Updated the “Link existing Autotask ticket” list to display the status label instead of the numeric status code.
+- Added a safe fallback chain so the UI shows:
+  statusLabel (API) -> status_label (legacy) -> numeric status.
+  
 ***
 
 ## v0.1.21

From 3c7f4c792689ff71baca1c4eb9388c7e741e9c55 Mon Sep 17 00:00:00 2001
From: Ivo Oskamp <ivooskamp@oskamp.info>
Date: Tue, 3 Feb 2026 10:31:44 +0100
Subject: [PATCH 63/63] Auto-commit local changes before build (2026-02-03
 10:31:44)

---
 .last-branch                                  |  2 +-
 .../app/integrations/autotask/client.py       | 38 ++++++++
 .../src/backend/app/main/routes_run_checks.py | 91 +++++++++++++++++++
 .../src/templates/main/run_checks.html        | 49 ++++++++++
 docs/changelog.md                             |  8 ++
 5 files changed, 187 insertions(+), 1 deletion(-)

diff --git a/.last-branch b/.last-branch
index 5b19c90..36e7b9e 100644
--- a/.last-branch
+++ b/.last-branch
@@ -1 +1 @@
-v20260120-11-runchecks-autotask-status-label
+v20260203-01-autotask-resolve-note
diff --git a/containers/backupchecks/src/backend/app/integrations/autotask/client.py b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
index e190716..36f0af5 100644
--- a/containers/backupchecks/src/backend/app/integrations/autotask/client.py
+++ b/containers/backupchecks/src/backend/app/integrations/autotask/client.py
@@ -483,6 +483,44 @@ class AutotaskClient:
         raise AutotaskError("Autotask did not return a ticket object.")
 
 
+    def update_ticket(self, ticket_payload: Dict[str, Any]) -> Dict[str, Any]:
+        """Update a Ticket via PUT /Tickets.
+
+        Autotask does not support PATCH for Tickets. PUT behaves as a full update.
+        Callers must construct a valid payload (typically by copying required fields
+        from a fresh GET /Tickets/{id} response) and changing only intended fields.
+        """
+
+        if not isinstance(ticket_payload, dict):
+            raise AutotaskError("Invalid ticket payload.")
+
+        try:
+            tid = int(ticket_payload.get("id") or 0)
+        except Exception:
+            tid = 0
+        if tid <= 0:
+            raise AutotaskError("Invalid ticket id in payload.")
+
+        data = self._request("PUT", "Tickets", json_body=ticket_payload)
+        if isinstance(data, dict):
+            if "item" in data and isinstance(data.get("item"), dict):
+                return data["item"]
+            if "items" in data and isinstance(data.get("items"), list) and data.get("items"):
+                first = data.get("items")[0]
+                if isinstance(first, dict):
+                    return first
+            # Some environments return the raw object
+            if "id" in data:
+                return data
+
+        items = self._as_items_list(data)
+        if items:
+            return items[0]
+
+        # PUT may return an empty body in some tenants; treat as success.
+        return {"id": tid}
+
+
     def get_resource(self, resource_id: int) -> Dict[str, Any]:
         """Retrieve a Resource by Autotask Resource ID.
 
diff --git a/containers/backupchecks/src/backend/app/main/routes_run_checks.py b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
index 1c4334e..6e67d72 100644
--- a/containers/backupchecks/src/backend/app/main/routes_run_checks.py
+++ b/containers/backupchecks/src/backend/app/main/routes_run_checks.py
@@ -1805,6 +1805,97 @@ def api_run_checks_autotask_link_existing_ticket():
             "internal_ticket_id": int(getattr(internal_ticket, "id", 0) or 0) if internal_ticket else 0,
         }
     )
+
+
+@main_bp.post("/api/run-checks/autotask-resolve-note")
+@login_required
+@roles_required("admin", "operator")
+def api_run_checks_autotask_resolve_note():
+    """Post a 'should be resolved' update to an existing Autotask ticket.
+
+    This first-step implementation does NOT close the ticket in Autotask.
+    It updates the Ticket description via PUT /Tickets (TicketNotes create is
+    not reliably supported across tenants).
+    """
+
+    data = request.get_json(silent=True) or {}
+
+    try:
+        run_id = int(data.get("run_id") or 0)
+    except Exception:
+        run_id = 0
+
+    if run_id <= 0:
+        return jsonify({"status": "error", "message": "Invalid parameters."}), 400
+
+    run = JobRun.query.get(run_id)
+    if not run:
+        return jsonify({"status": "error", "message": "Run not found."}), 404
+
+    if not getattr(run, "autotask_ticket_id", None):
+        return jsonify({"status": "error", "message": "Run has no Autotask ticket linked."}), 400
+
+    try:
+        ticket_id = int(run.autotask_ticket_id)
+    except Exception:
+        ticket_id = 0
+
+    if ticket_id <= 0:
+        return jsonify({"status": "error", "message": "Run has an invalid Autotask ticket id."}), 400
+
+    try:
+        client = _build_autotask_client_from_settings()
+        t = client.get_ticket(ticket_id)
+    except Exception as exc:
+        return jsonify({"status": "error", "message": f"Autotask ticket retrieval failed: {exc}"}), 400
+
+    if not isinstance(t, dict):
+        return jsonify({"status": "error", "message": "Autotask did not return a ticket object."}), 400
+
+    # Build an update payload based on known required fields from Postman validation.
+    required_fields = ["id", "companyID", "queueID", "title", "priority", "status", "dueDateTime"]
+    missing = [f for f in required_fields if t.get(f) in (None, "")]
+    if missing:
+        return jsonify(
+            {
+                "status": "error",
+                "message": "Cannot safely update Autotask ticket because required fields are missing: "
+                + ", ".join(missing),
+            }
+        ), 400
+
+    existing_desc = str(t.get("description") or "")
+
+    now = datetime.utcnow().strftime("%Y-%m-%d %H:%M:%SZ")
+    actor = (getattr(current_user, "email", None) or getattr(current_user, "username", None) or "operator")
+    marker = "[Backupchecks] Marked as resolved in Backupchecks"
+    note = f"\n\n{marker} (ticket remains open in Autotask). {now} by {actor}"
+
+    # Avoid runaway growth if the same action is clicked multiple times.
+    if marker in existing_desc:
+        new_desc = existing_desc
+    else:
+        new_desc = (existing_desc or "") + note
+
+    payload = {
+        "id": int(t.get("id")),
+        "companyID": t.get("companyID"),
+        "queueID": t.get("queueID"),
+        "title": t.get("title"),
+        "priority": t.get("priority"),
+        "status": t.get("status"),
+        "dueDateTime": t.get("dueDateTime"),
+        "description": new_desc,
+    }
+
+    try:
+        client.update_ticket(payload)
+    except Exception as exc:
+        return jsonify({"status": "error", "message": f"Autotask ticket update failed: {exc}"}), 400
+
+    return jsonify({"status": "ok"})
+
+
 @main_bp.post("/api/run-checks/mark-reviewed")
 @login_required
 @roles_required("admin", "operator")
diff --git a/containers/backupchecks/src/templates/main/run_checks.html b/containers/backupchecks/src/templates/main/run_checks.html
index d47509f..eda46b2 100644
--- a/containers/backupchecks/src/templates/main/run_checks.html
+++ b/containers/backupchecks/src/templates/main/run_checks.html
@@ -220,6 +220,7 @@
 	                          <div class="d-flex align-items-center justify-content-between">
 	                            <div class="fw-semibold">Autotask ticket</div>
 	                            <div class="d-flex gap-2">
+									<button type="button" class="btn btn-sm btn-outline-success" id="rcm_autotask_resolve_note">Resolve</button>
 								    <button type="button" class="btn btn-sm btn-outline-secondary" id="rcm_autotask_link_existing">Link existing</button>
 								    <button type="button" class="btn btn-sm btn-outline-primary" id="rcm_autotask_create">Create</button>
 								  </div>
@@ -891,6 +892,7 @@ table.addEventListener('change', function (e) {
 
     function bindInlineCreateForms() {
       var btnAutotask = document.getElementById('rcm_autotask_create');
+      var btnAutotaskResolveNote = document.getElementById('rcm_autotask_resolve_note');
       var btnAutotaskLink = document.getElementById('rcm_autotask_link_existing');
       var atInfo = document.getElementById('rcm_autotask_info');
       var atStatus = document.getElementById('rcm_autotask_status');
@@ -911,6 +913,7 @@ table.addEventListener('change', function (e) {
 
       function setDisabled(disabled) {
         if (btnAutotask) btnAutotask.disabled = disabled;
+        if (btnAutotaskResolveNote) btnAutotaskResolveNote.disabled = disabled;
         if (btnAutotaskLink) btnAutotaskLink.disabled = disabled;
         if (btnTicket) btnTicket.disabled = disabled;
         if (tCode) tCode.disabled = disabled;
@@ -963,6 +966,12 @@ table.addEventListener('change', function (e) {
           // Link existing is only meaningful when there is no PSA ticket linked to this run.
           btnAutotaskLink.style.display = hasAtTicket ? 'none' : '';
         }
+
+        if (btnAutotaskResolveNote) {
+          var hasTicket = !!(run && run.autotask_ticket_id);
+          // Resolve note is only meaningful when there is an active linked PSA ticket.
+          btnAutotaskResolveNote.style.display = (hasTicket && !isResolved && !isDeleted) ? '' : 'none';
+        }
       }
       window.__rcmRenderAutotaskInfo = renderAutotaskInfo;
 
@@ -1177,6 +1186,46 @@ table.addEventListener('change', function (e) {
         });
       }
 
+      if (btnAutotaskResolveNote) {
+        btnAutotaskResolveNote.addEventListener('click', function () {
+          if (!currentRunId) { alert('Select a run first.'); return; }
+          clearStatus();
+          if (!confirm('Add an update to the existing Autotask ticket that it should be resolved?\n\nThis will NOT close the ticket in Autotask.')) return;
+          if (atStatus) atStatus.textContent = 'Posting update...';
+          btnAutotaskResolveNote.disabled = true;
+          apiJson('/api/run-checks/autotask-resolve-note', {
+            method: 'POST',
+            body: JSON.stringify({run_id: currentRunId})
+          })
+          .then(function (j) {
+            if (!j || j.status !== 'ok') throw new Error((j && j.message) || 'Failed.');
+            if (atStatus) atStatus.textContent = 'Update posted.';
+            // Keep UI consistent (button visibility depends on run state).
+            var keepRunId = currentRunId;
+            if (currentJobId) {
+              return fetch('/api/run-checks/details?job_id=' + encodeURIComponent(currentJobId))
+                .then(function (r) { return r.json(); })
+                .then(function (payload) {
+                  currentPayload = payload;
+                  var idx = 0;
+                  var runs = (payload && payload.runs) || [];
+                  for (var i = 0; i < runs.length; i++) {
+                    if (String(runs[i].id) === String(keepRunId)) { idx = i; break; }
+                  }
+                  renderRun(payload, idx);
+                });
+            }
+          })
+          .catch(function (e) {
+            if (atStatus) atStatus.textContent = e.message || 'Failed.';
+            else alert(e.message || 'Failed.');
+          })
+          .finally(function () {
+            btnAutotaskResolveNote.disabled = false;
+          });
+        });
+      }
+
       if (btnRemark) {
         btnRemark.addEventListener('click', function () {
           if (!currentRunId) { alert('Select a run first.'); return; }
diff --git a/docs/changelog.md b/docs/changelog.md
index daa005a..22958ce 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -457,6 +457,14 @@ Changes:
 - Added a safe fallback chain so the UI shows:
   statusLabel (API) -> status_label (legacy) -> numeric status.
   
+## v20260203-01-autotask-resolve-note
+
+- Added a Resolve button to the Autotask ticket section on the Run Checks page.
+- Resolve action does NOT close the Autotask ticket.
+- Implemented functionality to add a note/update to the existing Autotask ticket indicating it is marked as resolved from Backupchecks.
+- Added backend API endpoint to handle the resolve-note action.
+- Extended Autotask client with a helper to update existing tickets via PUT.
+
 ***
 
 ## v0.1.21