From 3e6e301c7a177a6c736bb3fab6a6ebb2ffdb0dcd Mon Sep 17 00:00:00 2001
From: ialexeze <ialexeze@gmail.com>
Date: Wed, 13 May 2026 04:30:17 +0000
Subject: [PATCH 1/3] fix autoscaler issues: formalize computation for max
 queue depth

---
 .../cc/assets/templates/crd.html              | 124 ++++++++++--
 cmd/controlcenter/cc/client.go                |   1 +
 cmd/controlcenter/cc/types.go                 |   3 +
 cmd/internal/banner.go                        |   4 +-
 cmd/internal/konstructor.go                   |   8 +-
 docs/profiles/autoscale-profile.md            | 118 +++++++----
 .../01-based-on-own-metrics/load.sh           |  11 --
 .../01-without-autoscaler/README.md           | 115 +++++++++++
 .../cleanup.sh                                |   2 +-
 .../cr.yaml                                   |   0
 .../crd.yaml                                  |   0
 .../01-without-autoscaler/katalog.yaml        |  38 ++++
 .../01-without-autoscaler/load.sh             | 122 ++++++++++++
 .../02-based-on-own-metrics/README.md         | 140 +++++++++++++
 .../02-based-on-own-metrics/cleanup.sh        |  11 ++
 .../02-based-on-own-metrics/cr.yaml           |   8 +
 .../02-based-on-own-metrics/crd.yaml          |  43 ++++
 .../katalog.yaml                              |   2 +
 .../02-based-on-own-metrics/load.sh           | 122 ++++++++++++
 .../03-sibling-in-binary/README.md            | 186 ++++++++++++++++++
 .../03-sibling-in-binary/cleanup.sh           |  16 ++
 .../03-sibling-in-binary/cr-auditor.yaml      |   7 +
 .../03-sibling-in-binary/cr-loader.yaml       |   8 +
 .../03-sibling-in-binary/cr-processor.yaml    |   8 +
 .../03-sibling-in-binary/crd-auditor.yaml     |  43 ++++
 .../03-sibling-in-binary/crd-loader.yaml      |  46 +++++
 .../03-sibling-in-binary/crd-processor.yaml   |  49 +++++
 .../katalog.yaml                              |  45 +++--
 .../12-autoscale/03-sibling-in-binary/load.sh | 122 ++++++++++++
 pkg/autoscaler/autoscale_worker_info.go       |  18 +-
 pkg/autoscaler/autoscaler.go                  |   4 +-
 pkg/informer/type.go                          |   2 +-
 pkg/katalog/autoscale_profile_types.go        |  83 ++++++++
 pkg/katalog/autoscaler_profile.go             | 117 ++++++-----
 pkg/katalog/autosclaer_profile_test.go        |   6 +-
 pkg/katalog/validate.go                       |  14 +-
 pkg/katalog/validation_autoscale.go           |   6 +-
 pkg/konfig/konfig.go                          |  10 +-
 pkg/konfig/type.go                            |  10 +-
 pkg/kordinator/crd_health_handers.go          |  64 ++++--
 pkg/kordinator/dependency_kordinator.go       |   4 +-
 pkg/reconciler/generic.go                     |   6 +-
 pkg/reconciler/generic_autoscale.go           |   3 +-
 pkg/types/autoscale.go                        |   6 +-
 pkg/types/methods.go                          |  10 +
 45 files changed, 1574 insertions(+), 191 deletions(-)
 delete mode 100755 examples/advanced/12-autoscale/01-based-on-own-metrics/load.sh
 create mode 100644 examples/advanced/12-autoscale/01-without-autoscaler/README.md
 rename examples/advanced/12-autoscale/{01-based-on-own-metrics => 01-without-autoscaler}/cleanup.sh (83%)
 rename examples/advanced/12-autoscale/{01-based-on-own-metrics => 01-without-autoscaler}/cr.yaml (100%)
 rename examples/advanced/12-autoscale/{01-based-on-own-metrics => 01-without-autoscaler}/crd.yaml (100%)
 create mode 100644 examples/advanced/12-autoscale/01-without-autoscaler/katalog.yaml
 create mode 100755 examples/advanced/12-autoscale/01-without-autoscaler/load.sh
 create mode 100644 examples/advanced/12-autoscale/02-based-on-own-metrics/README.md
 create mode 100755 examples/advanced/12-autoscale/02-based-on-own-metrics/cleanup.sh
 create mode 100644 examples/advanced/12-autoscale/02-based-on-own-metrics/cr.yaml
 create mode 100644 examples/advanced/12-autoscale/02-based-on-own-metrics/crd.yaml
 rename examples/advanced/12-autoscale/{01-based-on-own-metrics => 02-based-on-own-metrics}/katalog.yaml (97%)
 create mode 100755 examples/advanced/12-autoscale/02-based-on-own-metrics/load.sh
 create mode 100644 examples/advanced/12-autoscale/03-sibling-in-binary/README.md
 create mode 100755 examples/advanced/12-autoscale/03-sibling-in-binary/cleanup.sh
 create mode 100644 examples/advanced/12-autoscale/03-sibling-in-binary/cr-auditor.yaml
 create mode 100644 examples/advanced/12-autoscale/03-sibling-in-binary/cr-loader.yaml
 create mode 100644 examples/advanced/12-autoscale/03-sibling-in-binary/cr-processor.yaml
 create mode 100644 examples/advanced/12-autoscale/03-sibling-in-binary/crd-auditor.yaml
 create mode 100644 examples/advanced/12-autoscale/03-sibling-in-binary/crd-loader.yaml
 create mode 100644 examples/advanced/12-autoscale/03-sibling-in-binary/crd-processor.yaml
 rename examples/advanced/12-autoscale/{02-sibling-in-binary => 03-sibling-in-binary}/katalog.yaml (80%)
 create mode 100755 examples/advanced/12-autoscale/03-sibling-in-binary/load.sh
 create mode 100644 pkg/katalog/autoscale_profile_types.go

diff --git a/cmd/controlcenter/cc/assets/templates/crd.html b/cmd/controlcenter/cc/assets/templates/crd.html
index 5bd06d86..7e781ac7 100644
--- a/cmd/controlcenter/cc/assets/templates/crd.html
+++ b/cmd/controlcenter/cc/assets/templates/crd.html
@@ -137,7 +137,7 @@
         <div class="cc-stat-card">
           <div class="cc-stat-label">Queue</div>
           <div class="cc-stat-value font-mono">{{ .CRD.QueueDepth }}</div>
-          <div class="cc-stat-sub">Max: {{ .CRD.MaxQueueDepth }}</div>
+          <div class="cc-stat-sub">Limit: {{ .CRD.MaxQueueDepth }}</div>
         </div>
         <div class="cc-stat-card">
           <div class="cc-stat-label">Reconciles</div>
@@ -165,10 +165,13 @@ <h2 class="cc-section-title" style="margin:0">Worker Pool</h2>
 
         <div style="background:var(--bg-surface);border:1px solid var(--border);border-radius:var(--radius);padding:20px">
           <div style="font-size:12px;color:var(--text-muted);margin-bottom:8px">
-            {{ .CRD.WorkersProcessing }} of {{ .CRD.Workers }} workers actively processing
+            {{ .CRD.WorkersProcessing }} of {{ .CRD.WorkersActive }} workers actively processing
+            {{ if ne .CRD.WorkersActive .CRD.Workers }}<span style="font-style:italic">(scaled from {{ .CRD.Workers }})</span>{{ end }}
           </div>
           <div class="cc-progress-bar-wrap" style="height:8px;margin-bottom:16px">
-            <div class="cc-progress-bar started" style="width:{{ div (mul .CRD.WorkersProcessing 100) .CRD.Workers }}%"></div>
+            {{ if gt .CRD.WorkersActive 0 }}
+            <div class="cc-progress-bar started" style="width:{{ div (mul .CRD.WorkersProcessing 100) .CRD.WorkersActive }}%"></div>
+            {{ end }}
           </div>
 
           <div class="cc-worker-grid" id="workerGrid">
@@ -231,7 +234,7 @@ <h2 class="cc-section-title" style="margin:0">Worker Pool</h2>
       </div>
 
       <!-- Autoscaler Info — only shown when autoscale is declared -->
-      {{ if .CRD.AutoscalerEnabled }}
+      {{ if and .CRD.AutoscalerEnabled .CRD.AutoscalerWorkers }}
       {{ $aw := .CRD.AutoscalerWorkers }}
       <div class="cc-section">
         <div class="cc-section-header">
@@ -275,26 +278,110 @@ <h2 class="cc-section-title" style="margin:0">
         </div>
 
         <!-- Expanded autoscale config — hidden by default -->
-        <div id="autoscalerDetail" class="hidden" style="margin-top:8px;background:var(--bg-surface);border:1px solid var(--border);border-radius:var(--radius);padding:20px;font-size:13px">
-          <div style="display:grid;grid-template-columns:1fr 1fr;gap:16px">
-            <div>
-              <div style="font-size:11px;font-weight:600;text-transform:uppercase;letter-spacing:0.05em;color:var(--text-muted);margin-bottom:8px">Capacity</div>
+        <div id="autoscalerDetail" class="hidden" 
+            style="margin-top:8px;background:var(--bg-surface);border:1px solid var(--border);
+                    border-radius:var(--radius);padding:20px;font-size:13px">
+
+          <!-- Card grid -->
+          <div style="display:grid;grid-template-columns:1fr 1fr 1fr;gap:16px">
+
+            <!-- Workers Card -->
+            <div style="background:var(--bg-elevated);border:1px solid var(--border);
+                        border-radius:var(--radius);padding:16px">
+              <div style="display:flex;align-items:center;gap:6px;
+                          font-size:11px;font-weight:600;text-transform:uppercase;
+                          letter-spacing:0.05em;color:var(--text-muted);margin-bottom:8px">
+                👷 Workers
+              </div>
               <table style="width:100%;border-collapse:collapse">
-                <tr><td style="color:var(--text-muted);padding:3px 0">Configured</td><td style="text-align:right;font-weight:500">{{ $aw.Configured }} workers</td></tr>
-                {{ if $aw.OverrideActive }}<tr><td style="color:var(--color-started);padding:3px 0">Override</td><td style="text-align:right;font-weight:500;color:var(--color-started)">{{ $aw.OverrideWorkers }} workers</td></tr>{{ end }}
-                <tr><td style="color:var(--text-muted);padding:3px 0">Max (pool)</td><td style="text-align:right;font-weight:500">{{ $aw.Max }}</td></tr>
+                <tr>
+                  <td style="color:var(--text-muted);padding:3px 0">Now</td>
+                  <td style="text-align:right;font-weight:500">
+                    {{ $aw.OverrideWorkers }}
+                  </td>
+                </tr>
+                <tr>
+                  <td style="color:var(--text-muted);padding:3px 0">Baseline</td>
+                  <td style="text-align:right;font-weight:500">
+                    {{ $aw.Configured }}
+                  </td>
+                </tr>
+                <tr>
+                  <td style="color:var(--text-muted);padding:3px 0">Max</td>
+                  <td style="text-align:right;font-weight:500">
+                    {{ $aw.Max }}
+                  </td>
+                </tr>
               </table>
             </div>
-            <div>
-              <div style="font-size:11px;font-weight:600;text-transform:uppercase;letter-spacing:0.05em;color:var(--text-muted);margin-bottom:8px">Queue</div>
+
+            <!-- Queue Card -->
+            <div style="background:var(--bg-elevated);border:1px solid var(--border);
+                        border-radius:var(--radius);padding:16px">
+              <div style="display:flex;align-items:center;gap:6px;
+                          font-size:11px;font-weight:600;text-transform:uppercase;
+                          letter-spacing:0.05em;color:var(--text-muted);margin-bottom:8px">
+                📥 Queue
+              </div>
+              <table style="width:100%;border-collapse:collapse">
+                <tr>
+                  <td style="color:var(--text-muted);padding:3px 0">Depth</td>
+                  <td style="text-align:right;font-weight:500">
+                    {{ $aw.QueueDepth }}
+                  </td>
+                </tr>
+                <tr>
+                  <td style="color:var(--text-muted);padding:3px 0">Limit</td>
+                  <td style="text-align:right;font-weight:500">
+                    {{ if gt .CRD.MaxQueueDepth 0 }}{{ .CRD.MaxQueueDepth }}{{ else }}∞{{ end }}
+                  </td>
+                </tr>
+                {{ if $aw.OverrideActive }}
+                <tr>
+                  <td style="color:var(--color-started);padding:3px 0">Override</td>
+                  <td style="text-align:right;font-weight:500;color:var(--color-started)">
+                    {{ $aw.QueueDepthEffective }}
+                  </td>
+                </tr>
+                {{ end }}
+              </table>
+            </div>
+
+            <!-- Resync Card -->
+            <div style="background:var(--bg-elevated);border:1px solid var(--border);
+                        border-radius:var(--radius);padding:16px">
+              <div style="display:flex;align-items:center;gap:6px;
+                          font-size:11px;font-weight:600;text-transform:uppercase;
+                          letter-spacing:0.05em;color:var(--text-muted);margin-bottom:8px">
+                🔁 Resync
+              </div>
               <table style="width:100%;border-collapse:collapse">
-                <tr><td style="color:var(--text-muted);padding:3px 0">Depth now</td><td style="text-align:right;font-weight:500">{{ $aw.QueueDepth }}</td></tr>
-                <tr><td style="color:var(--text-muted);padding:3px 0">Configured limit</td><td style="text-align:right;font-weight:500">{{ if gt $aw.QueueDepthConfigured 0 }}{{ $aw.QueueDepthConfigured }}{{ else }}∞{{ end }}</td></tr>
-                {{ if $aw.OverrideActive }}<tr><td style="color:var(--color-started);padding:3px 0">Effective limit</td><td style="text-align:right;font-weight:500;color:var(--color-started)">{{ $aw.QueueDepthEffective }}</td></tr>{{ end }}
+                <tr>
+                  <td style="color:var(--text-muted);padding:3px 0">Now</td>
+                  <td style="text-align:right;font-weight:500">
+                    {{ $aw.ResyncEffective }}
+                  </td>
+                </tr>
+                <tr>
+                  <td style="color:var(--text-muted);padding:3px 0">Baseline</td>
+                  <td style="text-align:right;font-weight:500">
+                    {{ $aw.ResyncConfigured }}
+                  </td>
+                </tr>
+                {{ if $aw.OverrideActive }}
+                <tr>
+                  <td style="color:var(--color-started);padding:3px 0">Override</td>
+                  <td style="text-align:right;font-weight:500;color:var(--color-started)">
+                    {{ $aw.ResyncEffective }}
+                  </td>
+                </tr>
+                {{ end }}
               </table>
             </div>
+
           </div>
         </div>
+        </div>
       </div>
       {{ end }}
 
@@ -350,7 +437,10 @@ <h2 class="cc-section-title">Queue Pressure</h2>
         <div style="background:var(--bg-surface);border:1px solid var(--border);border-radius:var(--radius);padding:20px">
           <div class="flex items-center justify-between mb-2">
             <span style="font-size:12px;color:var(--text-muted)">Queue Depth</span>
-            <span class="font-mono" style="font-size:13px;color:var(--text-primary)">{{ .CRD.QueueDepth }} / {{ .CRD.MaxQueueDepth }}</span>
+            <span class="font-mono" style="font-size:13px;color:var(--text-primary)">
+              {{ .CRD.QueueDepth }} / {{ .CRD.MaxQueueDepth }}
+              {{ if gt $queuePercent 0 }}<span style="color:var(--text-muted);font-size:11px;margin-left:4px">({{ $queuePercent }}%)</span>{{ end }}
+            </span>
           </div>
           <div class="cc-progress-bar-wrap" style="height:10px">
             <div class="cc-progress-bar{{ if gt $queuePercent 80 }} degraded{{ else if gt $queuePercent 50 }} pending{{ end }}"
diff --git a/cmd/controlcenter/cc/client.go b/cmd/controlcenter/cc/client.go
index fc7931a9..176cc062 100644
--- a/cmd/controlcenter/cc/client.go
+++ b/cmd/controlcenter/cc/client.go
@@ -82,6 +82,7 @@ func (c *Client) FetchCRDDetail(name string) (*CRDDetail, error) {
 		ResyncSource:             info.ResyncSource,
 		QueueDepth:               info.QueueDepth,
 		MaxQueueDepth:            info.MaxQueueDepth,
+		MaxQueueDepthSource:      info.MaxQueueDepthSource,
 		ResourceCount:            info.ResourceCount,
 		TotalReconciles:          info.TotalReconciles,
 		OperatorBox:              info.OperatorBox,
diff --git a/cmd/controlcenter/cc/types.go b/cmd/controlcenter/cc/types.go
index 5c824935..472eadd2 100644
--- a/cmd/controlcenter/cc/types.go
+++ b/cmd/controlcenter/cc/types.go
@@ -224,6 +224,9 @@ type AutoscalerWorkersInfo struct {
 	QueueDepth           int64   `json:"queueDepth"`
 	QueueDepthConfigured int     `json:"queueDepthConfigured"`
 	QueueDepthEffective  int     `json:"queueDepthEffective"`
+	Resync               string  `json:"resync"`
+	ResyncEffective      string  `json:"resyncEffective"`
+	ResyncConfigured     string  `json:"resyncConfigured"`
 	BusyPercent          float64 `json:"busyPercent"`
 }
 
diff --git a/cmd/internal/banner.go b/cmd/internal/banner.go
index 6d338e26..50b60be1 100644
--- a/cmd/internal/banner.go
+++ b/cmd/internal/banner.go
@@ -127,7 +127,7 @@ func printBanner(kfg *orkestraKfg, konductor string) {
 		if crd.Workers > 0 {
 			fmt.Printf("  Workers:       %d\n", crd.Workers)
 		} else {
-			fmt.Printf("  Workers:       %d (default)\n", kfg.konfig.Cluster().DefaultWorkers)
+			fmt.Printf("  Workers:       %d (default)\n", kfg.konfig.Katalog().DefaultWorkers)
 		}
 
 		if crd.Queue.MaxQueueDepth > 0 {
@@ -141,7 +141,7 @@ func printBanner(kfg *orkestraKfg, konductor string) {
 			fmt.Printf("  Resync:        %s\n", crd.Resync.String())
 		} else {
 			fmt.Printf("  Resync:        %s (default)\n",
-				kfg.konfig.Cluster().DefaultResync)
+				kfg.konfig.Katalog().DefaultResync)
 		}
 
 		if len(crd.DependsOn) > 0 {
diff --git a/cmd/internal/konstructor.go b/cmd/internal/konstructor.go
index ba5c3a3a..3dbfbc79 100644
--- a/cmd/internal/konstructor.go
+++ b/cmd/internal/konstructor.go
@@ -294,7 +294,7 @@ func konstructOrkestra(kfg *konfig.Konfig, m *merger.Merger, ctx context.Context
 	for _, crd := range kat.Enabled() {
 		crd := crd
 		gvk := crd.GVK().String()
-		crd.Workers = crd.SetWorkers(kfg.Cluster().DefaultWorkers)
+		crd.Workers = crd.SetWorkers(kfg.Katalog().DefaultWorkers)
 
 		object, _ := crd.GetRuntimeObjects()
 
@@ -549,9 +549,9 @@ func konstructOrkestra(kfg *konfig.Konfig, m *merger.Merger, ctx context.Context
 		defaultWq,
 		crdHealthMap,
 		orkHealth,
-		kfg.Cluster().DefaultWorkers,
+		kfg.Katalog().DefaultWorkers,
 		katalog.NewDependencyGraph(kat),
-		kfg.Cluster().ShutdownTimeout,
+		kfg.Katalog().ShutdownTimeout,
 	)
 
 	// ── 7. Komponent list ─────────────────────────────────────────────────────
@@ -577,7 +577,7 @@ func konstructOrkestra(kfg *konfig.Konfig, m *merger.Merger, ctx context.Context
 	// On OS signal (SIGTERM/SIGINT) or fatal error, calls Stop() in reverse.
 	// Graceful shutdown: drains queues before stopping workers.
 	o := ork.NewOrkestra(
-		kfg.Cluster().ShutdownGracePeriod,
+		kfg.Katalog().ShutdownGracePeriod,
 		kfg.Ork().LogLevel,
 	)
 	o.Register(komponents)
diff --git a/docs/profiles/autoscale-profile.md b/docs/profiles/autoscale-profile.md
index d60f2dcb..590ca44f 100644
--- a/docs/profiles/autoscale-profile.md
+++ b/docs/profiles/autoscale-profile.md
@@ -3,7 +3,14 @@
 
 An autoscale profile is a named preset that expands into a complete `operatorBox.autoscale` block at Katalog load time.
 
-Autoscale profiles are relative. They use the CRD's declared `workers` and `queue.maxQueueDepth` as a **baseline** and derive thresholds, overrides, and timing from it. The same profile behaves differently for a low-throughput operator with 2 workers than for a high-throughput operator with 20.
+Profiles are **relative**. They use the CRD’s declared `workers` and `queue.maxQueueDepth` as a **baseline**, then compute:
+
+- **override workers**  
+- **override queueDepth**  
+- **thresholds** (as a % of the override queueDepth)  
+- **interval + cooldown**  
+
+The same profile behaves differently for an operator with 2 workers than for one with 20.
 
 ---
 
@@ -11,17 +18,49 @@ Autoscale profiles are relative. They use the CRD's declared `workers` and `queu
 
 | Profile | Trigger | Workers Override | Queue Override | Interval | Cooldown |
 |---|---|---|---|---|---|
-| `burst` | queueDepth > baseline × 3 | baseline × 4 | baseline × 10 | 5s | 30s |
-| `steady` | queueDepth > baseline × 1.5 AND workers busy > 70% | baseline × 2 | baseline × 3 | 30s | 2m |
+| `burst` | queueDepth > 60% of override queueDepth | baseline × 4 | baseline × 10 | 5s | 30s |
+| `steady` | queueDepth > 40% of override queueDepth AND workersBusy > 70% | baseline × 2 | baseline × 3 | 30s | 2m |
 | `batch` | cron window 23:00 → 02:00 | baseline × 3 | baseline × 8 | 60s | 5m |
 | `latency-sensitive` | P95 reconcile > 200ms | ⌈baseline × 2.5⌉ | — | 15s | 1m |
-| `cost-optimized` | workers idle > 60% | max(1, baseline × 0.5) | baseline × 0.5 | 30s | 10m |
+| `cost-optimized` | workersIdle > 60% AND queueDepth > 80% of override queueDepth | max(1, baseline × 0.5) | baseline × 0.5 | 30s | 10m |
 
 ---
 
-## Usage
+## How profiles compute values
+
+Given:
+
+- baseline workers = `W`
+- baseline queueDepth = `Q`
+- maxQueueDepth = `M`
+- profile multipliers = `WorkerMultiplier`, `QueueMultiplier`
+- threshold percentage = `QueueThresholdPct`
+
+Profiles compute:
+
+### **1. Override queueDepth**
+```
+overrideQueueDepth = Q × QueueMultiplier
+```
+
+### **2. Threshold**
+```
+threshold = overrideQueueDepth × QueueThresholdPct
+```
+
+### **3. Override workers**
+```
+overrideWorkers = W × WorkerMultiplier
+```
+
+### **4. Interval + Cooldown**
+Taken directly from the profile.
+
+This ensures scaling happens **before** hitting the effective queue limit.
 
-Set `profile` inside the `autoscale:` block under `operatorBox:`:
+---
+
+## Usage
 
 ```yaml
 operatorBox:
@@ -32,20 +71,31 @@ operatorBox:
     profile: steady
 ```
 
-The profile expands using `workers: 4` and `maxQueueDepth: 100` as the baseline.
+For `steady`, with baseline:
+
+- workers = 4  
+- queueDepth = 100  
+
+The profile expands to:
 
-For `steady`, that produces:
+- override workers = 4 × 2 = **8**
+- override queueDepth = 100 × 3 = **300**
+- threshold = 300 × 0.40 = **120**
+- interval = 30s  
+- cooldown = 2m  
 
-- Trigger: queueDepth > 150 AND workersBusyPercent > 70
-- Override: workers → 8, queueDepth → 300
-- Interval: 30s, Cooldown: 2m
+Trigger:
+
+```
+queueDepth > 120 AND workersBusyPercent > 70
+```
 
 ---
 
 ## Rules
 
 **Profile or explicit — not both.**  
-A `profile:` cannot coexist with manual `autoscale` fields (`interval:`, `cooldown:`, `conditions:`, `do:`) on the same CRD. Use one or the other.
+A `profile:` cannot coexist with manual autoscale fields (`interval:`, `cooldown:`, `conditions:`, `do:`).
 
 ```yaml
 # Valid — profile only
@@ -79,37 +129,33 @@ An unrecognized profile name is a Katalog load error.
 ### `burst`
 *React instantly to spikes.*
 
-Short intervals, aggressive overrides. Intended for operators that see sudden flood events — mass ingestion, fan-out operations, event storms.
+Aggressive scaling, short interval, short cooldown.
 
 ```
-trigger:  queueDepth > workers × 3
+trigger:  queueDepth > 60% of override queueDepth
 override: workers × 4, queueDepth × 10
 timing:   interval 5s, cooldown 30s
 ```
 
-Reverts quickly once the queue drains. Use when bursts are short-lived.
-
 ---
 
 ### `steady`
 *Smooth, predictable scaling.*
 
-Two-condition trigger prevents scaling on noise — both queue depth and worker saturation must rise together. Moderate overrides. Long cooldown.
+Requires both queue pressure and worker saturation.
 
 ```
-trigger:  queueDepth > baseline × 1.5 AND workersBusyPercent > 70
+trigger:  queueDepth > 40% of override queueDepth AND workersBusyPercent > 70
 override: workers × 2, queueDepth × 3
 timing:   interval 30s, cooldown 2m
 ```
 
-Good default for operators that serve consistent API load.
-
 ---
 
 ### `batch`
 *Scale for a nightly processing window.*
 
-Time-triggered via cron. Activates at 23:00, stays active for 3 hours, then reverts. No metric conditions.
+Time-triggered only.
 
 ```
 trigger:  cron "0 23 * * *", duration 3h
@@ -117,14 +163,12 @@ override: workers × 3, queueDepth × 8
 timing:   interval 60s, cooldown 5m
 ```
 
-Use for ETL operators, nightly report generators, scheduled cleanup jobs.
-
 ---
 
 ### `latency-sensitive`
 *Keep reconcile latency low.*
 
-Triggers on P95 reconcile duration — not queue depth. Adds workers before the queue even builds. Only modifies worker count, not queue.
+Triggered by P95 latency, not queue depth.
 
 ```
 trigger:  reconcileDurationP95Ms > 200
@@ -132,37 +176,27 @@ override: workers × 2.5 (ceiling)
 timing:   interval 15s, cooldown 1m
 ```
 
-Use for operators where response time matters more than throughput — admission controllers, cert rotators, DNS operators.
-
 ---
 
 ### `cost-optimized`
 *Minimize resource usage during low activity.*
 
-Inverted logic — triggers when workers are mostly idle. Reduces both workers and queue depth. Long cooldown prevents flapping.
+Triggers when idle and queue is low.
 
 ```
-trigger:  workersIdlePercent > 60
+trigger:  workersIdlePercent > 60 AND queueDepth > 80% of override queueDepth
 override: max(1, workers × 0.5), queueDepth × 0.5
 timing:   interval 30s, cooldown 10m
 ```
 
-Use for operators that see highly variable load and you want to conserve resources during quiet periods.
-
 ---
 
 ## Choosing a profile
 
-Ask these questions:
-
-1. **Does this operator see sudden spikes?** → `burst`
-2. **Does this operator run a scheduled nightly job?** → `batch`
-3. **Does reconcile latency matter more than throughput?** → `latency-sensitive`
-4. **Is the load consistent and predictable?** → `steady`
-5. **Is the load low and I want to minimize footprint?** → `cost-optimized`
-
-If none fit cleanly, write the autoscale block manually. Profiles are shortcuts, not constraints.
-
----
+1. **Sudden spikes?** → `burst`  
+2. **Consistent load?** → `steady`  
+3. **Nightly batch window?** → `batch`  
+4. **Latency matters?** → `latency-sensitive`  
+5. **Save resources?** → `cost-optimized`  
 
-**Next →** [Probe Profile](./probe-profile.md)
+If none fit, write the autoscale block manually.
\ No newline at end of file
diff --git a/examples/advanced/12-autoscale/01-based-on-own-metrics/load.sh b/examples/advanced/12-autoscale/01-based-on-own-metrics/load.sh
deleted file mode 100755
index de8e1f3c..00000000
--- a/examples/advanced/12-autoscale/01-based-on-own-metrics/load.sh
+++ /dev/null
@@ -1,11 +0,0 @@
-for i in $(seq 1 200); do
-  kubectl apply -f - <<EOF
-apiVersion: autoscale.orkestra.io/v1alpha1
-kind: Ingestor
-metadata:
-  name: ingestor-$i
-spec:
-  image: nginx
-  replicas: 1
-EOF
-done
diff --git a/examples/advanced/12-autoscale/01-without-autoscaler/README.md b/examples/advanced/12-autoscale/01-without-autoscaler/README.md
new file mode 100644
index 00000000..79ed3bd3
--- /dev/null
+++ b/examples/advanced/12-autoscale/01-without-autoscaler/README.md
@@ -0,0 +1,115 @@
+# 01 — Without Autoscaler
+
+This example demonstrates **baseline operator behaviour in Orkestra when autoscaling is disabled**.  
+It mirrors how traditional Kubernetes operators behave under load:
+
+- You see **queue management** in action  
+- You observe **Control Center** metrics and worker activity  
+- You learn what happens when the reconcile queue exceeds its **queueDepth limit** (default: 100)
+
+---
+
+## Prerequisites
+
+- Ork CLI  
+- Kubernetes cluster (Kind works great)
+
+Install Ork CLI:
+
+```bash
+curl get.orkestra.sh | bash
+```
+
+Create a Kind cluster and run this example:
+
+```bash
+ork run -f katalog --dev
+```
+
+Start the Control Center:
+
+```bash
+ork control start
+```
+
+Visit: **http://localhost:8081**
+
+---
+
+## Run the Example
+
+### 1. Apply the CRD
+
+```bash
+kubectl apply -f crd.yaml
+```
+
+### 2. Apply the CR
+
+```bash
+kubectl apply -f cr.yaml
+```
+
+Watch the Control Center as resources are created:
+
+- A **Deployment** and **Service** appear  
+- **2 workers** stay mostly idle  
+- Reconciliation happens every minute - `resync`
+- Queue limit shows **100** (default) when you click the CRD
+
+> Note:
+> You can override the default queue limit by setting `queue.maxQueueDepth`. 
+
+---
+
+## Load the Ingestor
+
+Now let’s overload the operator with **150 Ingestor resources**.
+
+```bash
+./load.sh 150
+```
+
+Observe in the Control Center:
+
+- Queue depth rises  
+- Workers stay busy  
+- Once the queue reaches **100**, new items are **dropped** (default behaviour)
+
+### Expected logs
+
+```json
+{"level":"warn","key":"default/ingestor-123","gvk":"autoscale.orkestra.io/v1alpha1, Kind=Ingestor","limit":100,"depth":100,"message":"enqueue: queue depth limit reached — item dropped"}
+{"level":"warn","key":"default/ingestor-124","gvk":"autoscale.orkestra.io/v1alpha1, Kind=Ingestor","limit":100,"depth":100,"message":"enqueue: queue depth limit reached — item dropped"}
+{"level":"warn","key":"default/ingestor-125","gvk":"autoscale.orkestra.io/v1alpha1, Kind=Ingestor","limit":100,"depth":100,"message":"enqueue: queue depth limit reached — item dropped"}
+```
+
+Control Center will show:
+
+- **100/100**  
+- **99/100**  
+
+No errors — the operator simply drops excess events once the queue is full.
+
+This is **normal behaviour** for operators **without autoscale**.
+
+---
+
+## What You Learned
+
+- How Orkestra handles queue pressure without autoscaling  
+- How workers behave under load  
+- How the Control Center visualises queue depth and worker activity  
+- Why items get dropped when queueDepth is exceeded  
+
+In the **next example**, you’ll enable autoscaling and see how Orkestra prevents dropped items by dynamically scaling workers and adjusting queueDepth.
+
+---
+
+## Cleanup
+
+```bash
+chmod +x cleanup.sh && ./cleanup.sh
+```
+
+> This will take a few seconds to drain the queue and finalize cleanup.
\ No newline at end of file
diff --git a/examples/advanced/12-autoscale/01-based-on-own-metrics/cleanup.sh b/examples/advanced/12-autoscale/01-without-autoscaler/cleanup.sh
similarity index 83%
rename from examples/advanced/12-autoscale/01-based-on-own-metrics/cleanup.sh
rename to examples/advanced/12-autoscale/01-without-autoscaler/cleanup.sh
index 3ff00d03..a15dd187 100755
--- a/examples/advanced/12-autoscale/01-based-on-own-metrics/cleanup.sh
+++ b/examples/advanced/12-autoscale/01-without-autoscaler/cleanup.sh
@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 set -euo pipefail
-echo "Cleaning up 11-autoscale / 01-based-on-own-metrics..."
+echo "Cleaning up 11-autoscale / 01-without-autoscaler..."
 
 # Delete any load CRs first
 kubectl delete ingestors -l orkestra.load=true --ignore-not-found 2>/dev/null || true
diff --git a/examples/advanced/12-autoscale/01-based-on-own-metrics/cr.yaml b/examples/advanced/12-autoscale/01-without-autoscaler/cr.yaml
similarity index 100%
rename from examples/advanced/12-autoscale/01-based-on-own-metrics/cr.yaml
rename to examples/advanced/12-autoscale/01-without-autoscaler/cr.yaml
diff --git a/examples/advanced/12-autoscale/01-based-on-own-metrics/crd.yaml b/examples/advanced/12-autoscale/01-without-autoscaler/crd.yaml
similarity index 100%
rename from examples/advanced/12-autoscale/01-based-on-own-metrics/crd.yaml
rename to examples/advanced/12-autoscale/01-without-autoscaler/crd.yaml
diff --git a/examples/advanced/12-autoscale/01-without-autoscaler/katalog.yaml b/examples/advanced/12-autoscale/01-without-autoscaler/katalog.yaml
new file mode 100644
index 00000000..b2a6d5dd
--- /dev/null
+++ b/examples/advanced/12-autoscale/01-without-autoscaler/katalog.yaml
@@ -0,0 +1,38 @@
+apiVersion: orkestra.orkspace.io/v1
+kind: Katalog
+metadata:
+  name: without-autoscaler
+  author: orkspace
+  version: 0.1.0
+  description: >
+    Same Ingestor pattern but without the autoscaler enabled.
+    Useful for demonstrating baseline behaviour before autoscaling
+    is introduced.
+
+spec:
+  crds:
+    ingestor:
+      apiTypes:
+        group: autoscale.orkestra.io
+        version: v1alpha1
+        kind: Ingestor
+        plural: ingestors
+
+      workers: 2
+      resync: 60s
+
+      operatorBox:
+        status:
+          fields:
+            - path: phase
+              value: "Running"
+
+        onCreate:
+          deployments:
+            - image: "{{ .spec.image }}"
+              replicas: "{{ .spec.replicas }}"
+              port: 8080
+              reconcile: true
+          services:
+            - port: "8080"
+              reconcile: true
diff --git a/examples/advanced/12-autoscale/01-without-autoscaler/load.sh b/examples/advanced/12-autoscale/01-without-autoscaler/load.sh
new file mode 100755
index 00000000..cb9adae8
--- /dev/null
+++ b/examples/advanced/12-autoscale/01-without-autoscaler/load.sh
@@ -0,0 +1,122 @@
+#!/usr/bin/env bash
+# load.sh — generic CR loader for autoscale testing.
+#
+# Usage:
+#   ./load.sh <crd> <count>
+#   ./load.sh <crd> up <count>
+#   ./load.sh <crd> down <to>
+#
+# Defaults:
+#   CRD = ingestor
+#
+# Examples:
+#   ./load.sh processor 200
+#   ./load.sh loader up 150
+#   ./load.sh auditor down 10
+#   ./load.sh 100              # defaults to ingestor
+#   ./load.sh down 0           # defaults to ingestor
+
+set -euo pipefail
+
+DEFAULT_CRD="ingestor"
+
+CRD="${1:-$DEFAULT_CRD}"
+CMD="${2:-up}"
+ARG="${3:-}"
+
+# Shorthand: ./load.sh 200
+if [[ "$CRD" =~ ^[0-9]+$ ]]; then
+  ARG="$CRD"
+  CRD="$DEFAULT_CRD"
+  CMD="up"
+fi
+
+# Shorthand: ./load.sh processor 200
+if [[ "$CMD" =~ ^[0-9]+$ ]]; then
+  ARG="$CMD"
+  CMD="up"
+fi
+
+# Valid CRDs
+VALID_CRDS=("ingestor" "loader" "processor" "auditor")
+
+is_valid_crd() {
+  local x
+  for x in "${VALID_CRDS[@]}"; do
+    [[ "$x" == "$1" ]] && return 0
+  done
+  return 1
+}
+
+print_help() {
+  echo "Usage:"
+  echo "  $0 <crd> <count>"
+  echo "  $0 <crd> up <count>"
+  echo "  $0 <crd> down <to>"
+  echo
+  echo "Valid CRDs: ${VALID_CRDS[*]}"
+  echo "(crd defaults to '${DEFAULT_CRD}')"
+}
+
+# Validate CRD
+if ! is_valid_crd "$CRD"; then
+  echo "❌ Unknown CRD '$CRD'"
+  print_help
+  exit 1
+fi
+
+# Validate command
+if [[ "$CMD" != "up" && "$CMD" != "down" ]]; then
+  echo "❌ Unknown command '$CMD'"
+  print_help
+  exit 1
+fi
+
+# Emit correct spec for each CRD
+emit_spec() {
+  case "$1" in
+    loader|processor|ingestor)
+      cat <<EOF
+spec:
+  image: nginx
+  replicas: 1
+EOF
+      ;;
+    auditor)
+      cat <<EOF
+spec:
+  auditMode: "standard"
+EOF
+      ;;
+  esac
+}
+
+case "$CMD" in
+up)
+  COUNT="${ARG:-200}"
+  echo "→ Creating ${CRD}-1 through ${CRD}-${COUNT}"
+  for i in $(seq 1 "$COUNT"); do
+    kubectl apply -f - <<EOF
+apiVersion: autoscale.orkestra.io/v1alpha1
+kind: ${CRD^}
+metadata:
+  name: ${CRD}-$i
+  labels:
+    orkestra.load: "true"
+$(emit_spec "$CRD")
+EOF
+  done
+  echo "✔ Created ${COUNT} ${CRD^} resources"
+  ;;
+
+down)
+  TO="${ARG:-0}"
+  MAX="${4:-500}"
+  echo "→ Deleting ${CRD}-$((TO+1)) through ${CRD}-${MAX}"
+  for i in $(seq 1 "$MAX"); do
+    kubectl delete "$CRD" "${CRD}-$i" --ignore-not-found --wait=false || true
+  done
+  wait
+  echo "✔ Scaled down to ${TO} ${CRD^} resources"
+  ;;
+esac
diff --git a/examples/advanced/12-autoscale/02-based-on-own-metrics/README.md b/examples/advanced/12-autoscale/02-based-on-own-metrics/README.md
new file mode 100644
index 00000000..cb9cf751
--- /dev/null
+++ b/examples/advanced/12-autoscale/02-based-on-own-metrics/README.md
@@ -0,0 +1,140 @@
+# 02 — Based on Own Metrics
+
+This example demonstrates **how the Orkestra autoscaler works**, what happens when you configure it, and how to tune it for your operator.
+
+**What you learn:**
+
+- How Orkestra reads and reacts to your own CRD metrics
+- How autoscaling adjusts workers, queueDepth, and resync at runtime
+- How the Control Center visualises autoscaler state and overrides
+- How cooldown works and when baseline is restored
+
+**Builds on:** [01 — Without Autoscaler](../01-without-autoscaler/README.md)
+It reuses the same setup.
+
+---
+
+## Prerequisites
+
+- Ork CLI  
+- Kubernetes cluster (Kind works great)
+
+Install Ork CLI:
+
+```bash
+curl get.orkestra.sh | bash
+```
+
+Create a Kind cluster and run this example:
+
+```bash
+ork run -f katalog --dev
+```
+
+Start the Control Center:
+
+```bash
+ork control start
+```
+
+Visit: **http://localhost:8081**
+
+---
+
+## Run the Example
+
+### 1. Apply the CRD
+
+```bash
+kubectl apply -f crd.yaml
+```
+
+### 2. Apply the CR
+
+```bash
+kubectl apply -f cr.yaml
+```
+
+Watch the Control Center as resources are created:
+
+- A **Deployment** and **Service** appear  
+- **2 workers** stay mostly idle  
+- Reconciliation happens every minute (`resync`)  
+- Queue limit shows **100** (default)  
+- A new section **Autoscaler Baseline** appears under *Worker Pool*  
+  - Expand it to see the baseline configuration (exactly what you set in the katalog)
+
+> Note:  
+> You can override the default queue limit by setting `queue.maxQueueDepth`.
+
+---
+
+## Load the Ingestor
+
+Now let’s overload the operator with **150 Ingestor resources**.
+
+```bash
+./load.sh 150
+```
+
+Observe in the Control Center:
+
+- Queue depth rises  
+- Workers become fully busy  
+- Once the queue stays above **80** for the `autoscale.interval` (15s), autoscaling activates  
+- **Autoscaler Baseline** switches to **Autoscaler Override Active**  
+- You’ll see:
+  - queueDepth → **500**  
+  - workers → **8**  
+  - resync → **10s**  
+  - **no items dropped**
+
+In the *Worker Pool* section:
+
+```
+8 of 8 workers actively processing (scaled from 2)
+```
+
+### Expected logs
+
+```json
+{"level":"info","crd":"autoscale.orkestra.io/v1alpha1, Kind=Ingestor","workers":8,"message":"autoscaler: worker pool resized"}
+{"level":"info","crd":"autoscale.orkestra.io/v1alpha1, Kind=Ingestor","queueDepth":500,"message":"autoscaler: queue depth limit updated"}
+{"level":"info","crd":"autoscale.orkestra.io/v1alpha1, Kind=Ingestor","resync":10000,"message":"autoscaler: resync interval updated"}
+{"level":"info","crd":"Ingestor","workers":8,"queueDepth":500,"resync":10000,"message":"autoscaler: override applied"}
+```
+
+---
+
+## Reduce the Load
+
+Bring the load down to 50:
+
+```bash
+./load.sh down 50
+```
+
+What happens:
+
+- Queue depth begins to fall  
+- Workers remain at **8** until the queue stays below **80%** for the entire `autoscale.cooldown` (2 minutes)  
+- After cooldown, autoscaler restores the baseline
+
+### Expected logs
+
+```json
+{"level":"info","crd":"autoscale.orkestra.io/v1alpha1, Kind=Ingestor","workers":2,"message":"autoscaler: worker pool resized"}
+{"level":"info","crd":"autoscale.orkestra.io/v1alpha1, Kind=Ingestor","queueDepth":0,"message":"autoscaler: queue depth limit updated"}
+{"level":"info","crd":"autoscale.orkestra.io/v1alpha1, Kind=Ingestor","resync":60000,"message":"autoscaler: baseline restored"}
+```
+
+This is how Orkestra performs **per‑OperatorBox autoscaling**:  
+no restart, no redeployment — everything happens live at runtime based on your declarative katalog.
+
+---
+
+## Cleanup
+
+```bash
+chmod +x cleanup.sh && ./cleanup.sh
+```
\ No newline at end of file
diff --git a/examples/advanced/12-autoscale/02-based-on-own-metrics/cleanup.sh b/examples/advanced/12-autoscale/02-based-on-own-metrics/cleanup.sh
new file mode 100755
index 00000000..ad6aeee5
--- /dev/null
+++ b/examples/advanced/12-autoscale/02-based-on-own-metrics/cleanup.sh
@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+set -euo pipefail
+echo "Cleaning up 11-autoscale / 02-based-on-own-metrics..."
+
+# Delete any load CRs first
+kubectl delete ingestors -l orkestra.load=true --ignore-not-found 2>/dev/null || true
+
+kubectl delete -f cr.yaml  --ignore-not-found
+kubectl delete -f crd.yaml --ignore-not-found
+
+echo "✓ Done. Stop 'ork run' with Ctrl+C if still running."
diff --git a/examples/advanced/12-autoscale/02-based-on-own-metrics/cr.yaml b/examples/advanced/12-autoscale/02-based-on-own-metrics/cr.yaml
new file mode 100644
index 00000000..19975ceb
--- /dev/null
+++ b/examples/advanced/12-autoscale/02-based-on-own-metrics/cr.yaml
@@ -0,0 +1,8 @@
+apiVersion: autoscale.orkestra.io/v1alpha1
+kind: Ingestor
+metadata:
+  name: my-ingestor
+  namespace: default
+spec:
+  image: nginx:stable-alpine
+  replicas: 1
diff --git a/examples/advanced/12-autoscale/02-based-on-own-metrics/crd.yaml b/examples/advanced/12-autoscale/02-based-on-own-metrics/crd.yaml
new file mode 100644
index 00000000..63ea856b
--- /dev/null
+++ b/examples/advanced/12-autoscale/02-based-on-own-metrics/crd.yaml
@@ -0,0 +1,43 @@
+apiVersion: apiextensions.k8s.io/v1
+kind: CustomResourceDefinition
+metadata:
+  name: ingestors.autoscale.orkestra.io
+spec:
+  group: autoscale.orkestra.io
+  versions:
+    - name: v1alpha1
+      served: true
+      storage: true
+      subresources:
+        status: {}
+      additionalPrinterColumns:
+        - name: Image
+          type: string
+          jsonPath: .spec.image
+        - name: Phase
+          type: string
+          jsonPath: .status.phase
+        - name: Age
+          type: date
+          jsonPath: .metadata.creationTimestamp
+      schema:
+        openAPIV3Schema:
+          type: object
+          properties:
+            spec:
+              type: object
+              required: [image]
+              properties:
+                image:
+                  type: string
+                replicas:
+                  type: integer
+                  default: 1
+            status:
+              type: object
+              x-kubernetes-preserve-unknown-fields: true
+  names:
+    kind: Ingestor
+    plural: ingestors
+    singular: ingestor
+  scope: Namespaced
diff --git a/examples/advanced/12-autoscale/01-based-on-own-metrics/katalog.yaml b/examples/advanced/12-autoscale/02-based-on-own-metrics/katalog.yaml
similarity index 97%
rename from examples/advanced/12-autoscale/01-based-on-own-metrics/katalog.yaml
rename to examples/advanced/12-autoscale/02-based-on-own-metrics/katalog.yaml
index 4dfa07a1..c2ea6e98 100644
--- a/examples/advanced/12-autoscale/01-based-on-own-metrics/katalog.yaml
+++ b/examples/advanced/12-autoscale/02-based-on-own-metrics/katalog.yaml
@@ -2,6 +2,8 @@ apiVersion: orkestra.orkspace.io/v1
 kind: Katalog
 metadata:
   name: autoscale-own-metrics
+  author: orkspace
+  version: 0.1.0
   description: >
     Autoscaling based on the CRD's own queue depth.
     When the Ingestor's reconcile queue exceeds 80 items, Orkestra
diff --git a/examples/advanced/12-autoscale/02-based-on-own-metrics/load.sh b/examples/advanced/12-autoscale/02-based-on-own-metrics/load.sh
new file mode 100755
index 00000000..cb9adae8
--- /dev/null
+++ b/examples/advanced/12-autoscale/02-based-on-own-metrics/load.sh
@@ -0,0 +1,122 @@
+#!/usr/bin/env bash
+# load.sh — generic CR loader for autoscale testing.
+#
+# Usage:
+#   ./load.sh <crd> <count>
+#   ./load.sh <crd> up <count>
+#   ./load.sh <crd> down <to>
+#
+# Defaults:
+#   CRD = ingestor
+#
+# Examples:
+#   ./load.sh processor 200
+#   ./load.sh loader up 150
+#   ./load.sh auditor down 10
+#   ./load.sh 100              # defaults to ingestor
+#   ./load.sh down 0           # defaults to ingestor
+
+set -euo pipefail
+
+DEFAULT_CRD="ingestor"
+
+CRD="${1:-$DEFAULT_CRD}"
+CMD="${2:-up}"
+ARG="${3:-}"
+
+# Shorthand: ./load.sh 200
+if [[ "$CRD" =~ ^[0-9]+$ ]]; then
+  ARG="$CRD"
+  CRD="$DEFAULT_CRD"
+  CMD="up"
+fi
+
+# Shorthand: ./load.sh processor 200
+if [[ "$CMD" =~ ^[0-9]+$ ]]; then
+  ARG="$CMD"
+  CMD="up"
+fi
+
+# Valid CRDs
+VALID_CRDS=("ingestor" "loader" "processor" "auditor")
+
+is_valid_crd() {
+  local x
+  for x in "${VALID_CRDS[@]}"; do
+    [[ "$x" == "$1" ]] && return 0
+  done
+  return 1
+}
+
+print_help() {
+  echo "Usage:"
+  echo "  $0 <crd> <count>"
+  echo "  $0 <crd> up <count>"
+  echo "  $0 <crd> down <to>"
+  echo
+  echo "Valid CRDs: ${VALID_CRDS[*]}"
+  echo "(crd defaults to '${DEFAULT_CRD}')"
+}
+
+# Validate CRD
+if ! is_valid_crd "$CRD"; then
+  echo "❌ Unknown CRD '$CRD'"
+  print_help
+  exit 1
+fi
+
+# Validate command
+if [[ "$CMD" != "up" && "$CMD" != "down" ]]; then
+  echo "❌ Unknown command '$CMD'"
+  print_help
+  exit 1
+fi
+
+# Emit correct spec for each CRD
+emit_spec() {
+  case "$1" in
+    loader|processor|ingestor)
+      cat <<EOF
+spec:
+  image: nginx
+  replicas: 1
+EOF
+      ;;
+    auditor)
+      cat <<EOF
+spec:
+  auditMode: "standard"
+EOF
+      ;;
+  esac
+}
+
+case "$CMD" in
+up)
+  COUNT="${ARG:-200}"
+  echo "→ Creating ${CRD}-1 through ${CRD}-${COUNT}"
+  for i in $(seq 1 "$COUNT"); do
+    kubectl apply -f - <<EOF
+apiVersion: autoscale.orkestra.io/v1alpha1
+kind: ${CRD^}
+metadata:
+  name: ${CRD}-$i
+  labels:
+    orkestra.load: "true"
+$(emit_spec "$CRD")
+EOF
+  done
+  echo "✔ Created ${COUNT} ${CRD^} resources"
+  ;;
+
+down)
+  TO="${ARG:-0}"
+  MAX="${4:-500}"
+  echo "→ Deleting ${CRD}-$((TO+1)) through ${CRD}-${MAX}"
+  for i in $(seq 1 "$MAX"); do
+    kubectl delete "$CRD" "${CRD}-$i" --ignore-not-found --wait=false || true
+  done
+  wait
+  echo "✔ Scaled down to ${TO} ${CRD^} resources"
+  ;;
+esac
diff --git a/examples/advanced/12-autoscale/03-sibling-in-binary/README.md b/examples/advanced/12-autoscale/03-sibling-in-binary/README.md
new file mode 100644
index 00000000..8feeddf0
--- /dev/null
+++ b/examples/advanced/12-autoscale/03-sibling-in-binary/README.md
@@ -0,0 +1,186 @@
+# 03 — Autoscale: Sibling‑in‑Binary
+
+This example builds on **[02-based-on-own-metrics](../02-based-on-own-metrics/README.md)** and introduces **two new autoscaling concepts** inside a *single operator binary*:
+
+---
+
+## New Concepts Introduced
+
+### **1. Autoscale Profiles (`autoscale.profile`)**
+A profile is a **preset autoscaling strategy**.  
+You declare intent — Orkestra computes the parameters.
+
+Available profiles include:
+
+- **burst** — aggressive scaling for sudden spikes  
+- **steady** — smooth, conservative scaling  
+- **batch** — optimized for large, predictable workloads  
+- **latency-sensitive** — prioritizes fast reconciliation  
+- **cost-optimized** — minimal scaling, slower but cheaper  
+
+In this example, the **Processor** uses:
+
+```
+autoscale:
+  profile: burst
+```
+
+Orkestra expands this into a full autoscale configuration:
+
+- workers: baseline × 4  
+- queueDepth: baseline × 10  
+- interval: 5s  
+- cooldown: 30s  
+- trigger: computed from metrics.queueDepth  
+
+You can see the computed values in the **Control Center → Autoscaler Baseline** panel.
+
+---
+
+### **2. Cross‑CRD Autoscaling (Sibling Metrics)**
+The **Auditor** autoscaler watches **Loader’s live queue depth**:
+
+```
+field: cross.loader.metrics.queueDepth
+```
+
+This is *zero‑latency*, *in‑process*, *no network call*, *no external metrics*.
+
+When Loader’s queue exceeds 75 for 30 seconds:
+
+- Auditor workers scale from **1 → 4**  
+- Auditor resync tightens from **60s → 15s**
+
+This demonstrates **runtime dependency scaling** between CRDs in the same binary — without any `dependsOn` declaration.
+
+---
+
+## What You Learn
+
+- How **autoscale profiles** work and how Orkestra computes full autoscale parameters from a single line.
+- How **multiple CRDs inside the same operator binary** can autoscale independently.
+- How to use **cross.<crd>.metrics.\*** to read sibling metrics in real time.
+- How **profile‑based autoscaling** differs from **explicit autoscaling**.
+- How downstream CRDs (Processor, Auditor) react differently to load on the upstream Loader.
+- How Orkestra performs **cross‑operator dependency scaling** without restarts, redeployments, or external metrics.
+- How the Control Center visualizes **baseline vs override** for multiple CRDs simultaneously.
+
+---
+
+## Prerequisites
+
+- Ork CLI  
+- Kubernetes cluster (Kind works great)
+
+Install Ork CLI:
+
+```bash
+curl get.orkestra.sh | bash
+```
+
+Create a Kind cluster and run this example:
+
+```bash
+ork run -f katalog --dev
+```
+
+Start the Control Center:
+
+```bash
+ork control start
+```
+
+Visit: **http://localhost:8081**
+
+---
+
+## Run the Example
+
+### **1. Apply the CRDs**
+
+```bash
+kubectl apply -f crd-loader.yaml
+kubectl apply -f crd-processor.yaml
+kubectl apply -f crd-auditor.yaml
+```
+
+### **2. Apply the CRs**
+
+```bash
+kubectl apply -f cr-loader.yaml
+kubectl apply -f cr-processor.yaml
+kubectl apply -f cr-auditor.yaml
+```
+
+Watch in the Control Center as each CRD creates its Deployment/Service and begins reconciling.
+
+> **Note:**  
+> Only **Loader** has *no autoscaler*.  
+> Processor and Auditor both autoscale — but in *different ways*.
+
+---
+
+# Load the Processor (Profile‑Based Autoscale)
+
+```bash
+./load.sh processor up 100
+```
+
+Observe:
+
+- Processor queue grows  
+- Processor autoscaler (profile: burst) activates  
+- Workers scale from **2 → 8**  
+- QueueDepth expands from **100 → 1000**  
+- Resync tightens from **30s → 5s**  
+- Loader and Auditor remain unaffected  
+
+This demonstrates **profile‑based autoscaling on own metrics**.
+
+---
+
+# Load the Loader (Cross‑CRD Autoscale)
+
+```bash
+./load.sh loader up 100
+```
+
+Observe:
+
+- Loader queue grows  
+- Once queue hits **75+ for 30s**, Auditor autoscaler activates  
+- Auditor workers scale **1 → 4**  
+- Auditor resync tightens **60s → 15s**  
+- Loader begins dropping items once queue hits its limit (75)  
+- Processor remains unaffected  
+
+This demonstrates **cross‑CRD autoscaling** using sibling metrics.
+
+---
+
+# Reduce the Load
+
+```bash
+./load.sh loader down 10
+```
+
+Notes:
+
+- Loader queue drains slowly — this is expected.  
+- Auditor remains scaled up until Loader queue stays **below 75** for the full **5‑minute cooldown**.  
+- After cooldown, Auditor returns to baseline (1 worker, 60s resync).
+
+This is **runtime dependency scaling** without any explicit `dependsOn` configuration.
+
+No restarts.  
+No redeployments.  
+No external metrics.  
+All live, all in‑process.
+
+---
+
+## Cleanup
+
+```bash
+chmod +x cleanup.sh && ./cleanup.sh
+```
diff --git a/examples/advanced/12-autoscale/03-sibling-in-binary/cleanup.sh b/examples/advanced/12-autoscale/03-sibling-in-binary/cleanup.sh
new file mode 100755
index 00000000..e0bf37e3
--- /dev/null
+++ b/examples/advanced/12-autoscale/03-sibling-in-binary/cleanup.sh
@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+set -euo pipefail
+echo "Cleaning up 11-autoscale / 03-sibling-in-Binary..."
+
+# Delete any load CRs first
+kubectl delete ingestors -l orkestra.load=true --ignore-not-found 2>/dev/null || true
+
+kubectl delete -f cr-loader.yaml  --ignore-not-found
+kubectl delete -f cr-processor.yaml  --ignore-not-found
+kubectl delete -f cr-auditor.yaml  --ignore-not-found
+
+kubectl delete -f crd-loader.yaml  --ignore-not-found
+kubectl delete -f crd-processor.yaml  --ignore-not-found
+kubectl delete -f crd-auditor.yaml  --ignore-not-found
+
+echo "✓ Done. Stop 'ork run' with Ctrl+C if still running."
diff --git a/examples/advanced/12-autoscale/03-sibling-in-binary/cr-auditor.yaml b/examples/advanced/12-autoscale/03-sibling-in-binary/cr-auditor.yaml
new file mode 100644
index 00000000..938ab99e
--- /dev/null
+++ b/examples/advanced/12-autoscale/03-sibling-in-binary/cr-auditor.yaml
@@ -0,0 +1,7 @@
+apiVersion: autoscale.orkestra.io/v1alpha1
+kind: Auditor
+metadata:
+  name: my-auditor
+  namespace: default
+spec:
+  auditMode: "standard"
diff --git a/examples/advanced/12-autoscale/03-sibling-in-binary/cr-loader.yaml b/examples/advanced/12-autoscale/03-sibling-in-binary/cr-loader.yaml
new file mode 100644
index 00000000..3a2b0680
--- /dev/null
+++ b/examples/advanced/12-autoscale/03-sibling-in-binary/cr-loader.yaml
@@ -0,0 +1,8 @@
+apiVersion: autoscale.orkestra.io/v1alpha1
+kind: Loader
+metadata:
+  name: my-loader
+  namespace: default
+spec:
+  image: nginx:stable-alpine
+  replicas: 1
\ No newline at end of file
diff --git a/examples/advanced/12-autoscale/03-sibling-in-binary/cr-processor.yaml b/examples/advanced/12-autoscale/03-sibling-in-binary/cr-processor.yaml
new file mode 100644
index 00000000..d8609c30
--- /dev/null
+++ b/examples/advanced/12-autoscale/03-sibling-in-binary/cr-processor.yaml
@@ -0,0 +1,8 @@
+apiVersion: autoscale.orkestra.io/v1alpha1
+kind: Processor
+metadata:
+  name: my-processor
+  namespace: default
+spec:
+  image: nginx:stable-alpine
+  replicas: 1
diff --git a/examples/advanced/12-autoscale/03-sibling-in-binary/crd-auditor.yaml b/examples/advanced/12-autoscale/03-sibling-in-binary/crd-auditor.yaml
new file mode 100644
index 00000000..b95fd158
--- /dev/null
+++ b/examples/advanced/12-autoscale/03-sibling-in-binary/crd-auditor.yaml
@@ -0,0 +1,43 @@
+apiVersion: apiextensions.k8s.io/v1
+kind: CustomResourceDefinition
+metadata:
+  name: auditors.autoscale.orkestra.io
+spec:
+  group: autoscale.orkestra.io
+  names:
+    kind: Auditor
+    plural: auditors
+    singular: auditor
+  scope: Namespaced
+  versions:
+    - name: v1alpha1
+      served: true
+      storage: true
+      subresources:
+        status: {}
+      additionalPrinterColumns:
+        - name: AuditMode
+          type: string
+          jsonPath: .spec.auditMode
+        - name: Autoscale
+          type: string
+          jsonPath: .status.autoscaleActive
+        - name: Phase
+          type: string
+          jsonPath: .status.phase
+        - name: Age
+          type: date
+          jsonPath: .metadata.creationTimestamp
+      schema:
+        openAPIV3Schema:
+          type: object
+          properties:
+            spec:
+              type: object
+              properties:
+                auditMode:
+                  type: string
+                  nullable: true
+            status:
+              type: object
+              x-kubernetes-preserve-unknown-fields: true
diff --git a/examples/advanced/12-autoscale/03-sibling-in-binary/crd-loader.yaml b/examples/advanced/12-autoscale/03-sibling-in-binary/crd-loader.yaml
new file mode 100644
index 00000000..2012b4a0
--- /dev/null
+++ b/examples/advanced/12-autoscale/03-sibling-in-binary/crd-loader.yaml
@@ -0,0 +1,46 @@
+apiVersion: apiextensions.k8s.io/v1
+kind: CustomResourceDefinition
+metadata:
+  name: loaders.autoscale.orkestra.io
+spec:
+  group: autoscale.orkestra.io
+  names:
+    kind: Loader
+    plural: loaders
+    singular: loader
+  scope: Namespaced
+  versions:
+    - name: v1alpha1
+      served: true
+      storage: true
+      subresources:
+        status: {}
+      additionalPrinterColumns:
+        - name: Image
+          type: string
+          jsonPath: .spec.image
+        - name: Phase
+          type: string
+          jsonPath: .status.phase
+        - name: Age
+          type: date
+          jsonPath: .metadata.creationTimestamp
+      schema:
+        openAPIV3Schema:
+          type: object
+          properties:
+            spec:
+              type: object
+              required: [image]
+              properties:
+                image:
+                  type: string
+                replicas:
+                  type: integer
+                  default: 1
+                auditMode:
+                  type: string
+                  nullable: true
+            status:
+              type: object
+              x-kubernetes-preserve-unknown-fields: true
diff --git a/examples/advanced/12-autoscale/03-sibling-in-binary/crd-processor.yaml b/examples/advanced/12-autoscale/03-sibling-in-binary/crd-processor.yaml
new file mode 100644
index 00000000..10f6ba1b
--- /dev/null
+++ b/examples/advanced/12-autoscale/03-sibling-in-binary/crd-processor.yaml
@@ -0,0 +1,49 @@
+apiVersion: apiextensions.k8s.io/v1
+kind: CustomResourceDefinition
+metadata:
+  name: processors.autoscale.orkestra.io
+spec:
+  group: autoscale.orkestra.io
+  names:
+    kind: Processor
+    plural: processors
+    singular: processor
+  scope: Namespaced
+  versions:
+    - name: v1alpha1
+      served: true
+      storage: true
+      subresources:
+        status: {}
+      additionalPrinterColumns:
+        - name: Image
+          type: string
+          jsonPath: .spec.image
+        - name: Workers
+          type: integer
+          jsonPath: .status.workers
+        - name: Autoscale
+          type: string
+          jsonPath: .status.autoscaleActive
+        - name: Phase
+          type: string
+          jsonPath: .status.phase
+        - name: Age
+          type: date
+          jsonPath: .metadata.creationTimestamp
+      schema:
+        openAPIV3Schema:
+          type: object
+          properties:
+            spec:
+              type: object
+              required: [image]
+              properties:
+                image:
+                  type: string
+                replicas:
+                  type: integer
+                  default: 1
+            status:
+              type: object
+              x-kubernetes-preserve-unknown-fields: true
diff --git a/examples/advanced/12-autoscale/02-sibling-in-binary/katalog.yaml b/examples/advanced/12-autoscale/03-sibling-in-binary/katalog.yaml
similarity index 80%
rename from examples/advanced/12-autoscale/02-sibling-in-binary/katalog.yaml
rename to examples/advanced/12-autoscale/03-sibling-in-binary/katalog.yaml
index 6f958276..4153e470 100644
--- a/examples/advanced/12-autoscale/02-sibling-in-binary/katalog.yaml
+++ b/examples/advanced/12-autoscale/03-sibling-in-binary/katalog.yaml
@@ -2,6 +2,8 @@ apiVersion: orkestra.orkspace.io/v1
 kind: Katalog
 metadata:
   name: autoscale-sibling
+  author: orkspace
+  version: 0.1.0
   description: >
     Cross-CRD autoscaling — two approaches in one binary.
 
@@ -50,17 +52,22 @@ spec:
             - port: "8080"
 
     # ── Processor ────────────────────────────────────────────────────────────
-    # Profile-based autoscale. Declare profile: burst and Orkestra does the rest.
+    # Profile-based autoscale. Declare profile: burst and Orkestra computes the
+    # full autoscale spec at katalog load time.
     #
-    # burst profile expands to:
-    #   workers:    baseline × 4   (2 → 8)
-    #   queueDepth: baseline × 10  (100 → 1000)
-    #   interval:   5s
-    #   cooldown:   30s
-    #   trigger:    metrics.queueDepth > threshold (computed from baseline)
+    # burst profile expands using baseline:
+    #   workers:    baseline × 4
+    #   queueDepth: baseline × 10
     #
-    # Cannot be combined with interval/cooldown/conditions/do —
-    # the profile owns those fields entirely.
+    # threshold is computed as:
+    #   threshold = overrideQueueDepth × 0.60
+    #
+    # timing:
+    #   interval: 5s
+    #   cooldown: 30s
+    #
+    # Cannot be combined with interval/cooldown/conditions/do — the profile owns
+    # the entire autoscale block.
     processor:
       apiTypes:
         group: autoscale.orkestra.io
@@ -79,10 +86,10 @@ spec:
           fields:
             - path: phase
               value: "Running"
-            - path: autoscaleActive
-              value: "{{ .metrics.autoscaleActive }}"
-            - path: workers
-              value: "{{ .metrics.workers }}"
+            # - path: autoscaleActive
+            #   value: "{{ .metrics.autoscaleActive }}"
+            # - path: workers
+            #   value: "{{ .metrics.workers }}"
 
         onCreate:
           deployments:
@@ -108,13 +115,19 @@ spec:
       resync: 60s
 
       operatorBox:
+        # cross:
+        #   - crd: loader
+        #     selector:
+        #       name: "{{ .metadata.name }}"
+        #       namespace: "{{ .metadata.namespace }}"
+        #     as: loader
         autoscale:
           interval: 30s
           cooldown: 5m
           conditions:
             when:
               - field: cross.loader.metrics.queueDepth
-                greaterThan: "150"
+                greaterThan: "75"
           do:
             workers: 4
             resync: 15s
@@ -123,8 +136,8 @@ spec:
           fields:
             - path: phase
               value: "Running"
-            - path: autoscaleActive
-              value: "{{ .metrics.autoscaleActive }}"
+            # - path: autoscaleActive
+            #   value: "{{ .metrics.autoscaleActive }}"
 
         onCreate:
           configMaps:
diff --git a/examples/advanced/12-autoscale/03-sibling-in-binary/load.sh b/examples/advanced/12-autoscale/03-sibling-in-binary/load.sh
new file mode 100755
index 00000000..cb9adae8
--- /dev/null
+++ b/examples/advanced/12-autoscale/03-sibling-in-binary/load.sh
@@ -0,0 +1,122 @@
+#!/usr/bin/env bash
+# load.sh — generic CR loader for autoscale testing.
+#
+# Usage:
+#   ./load.sh <crd> <count>
+#   ./load.sh <crd> up <count>
+#   ./load.sh <crd> down <to>
+#
+# Defaults:
+#   CRD = ingestor
+#
+# Examples:
+#   ./load.sh processor 200
+#   ./load.sh loader up 150
+#   ./load.sh auditor down 10
+#   ./load.sh 100              # defaults to ingestor
+#   ./load.sh down 0           # defaults to ingestor
+
+set -euo pipefail
+
+DEFAULT_CRD="ingestor"
+
+CRD="${1:-$DEFAULT_CRD}"
+CMD="${2:-up}"
+ARG="${3:-}"
+
+# Shorthand: ./load.sh 200
+if [[ "$CRD" =~ ^[0-9]+$ ]]; then
+  ARG="$CRD"
+  CRD="$DEFAULT_CRD"
+  CMD="up"
+fi
+
+# Shorthand: ./load.sh processor 200
+if [[ "$CMD" =~ ^[0-9]+$ ]]; then
+  ARG="$CMD"
+  CMD="up"
+fi
+
+# Valid CRDs
+VALID_CRDS=("ingestor" "loader" "processor" "auditor")
+
+is_valid_crd() {
+  local x
+  for x in "${VALID_CRDS[@]}"; do
+    [[ "$x" == "$1" ]] && return 0
+  done
+  return 1
+}
+
+print_help() {
+  echo "Usage:"
+  echo "  $0 <crd> <count>"
+  echo "  $0 <crd> up <count>"
+  echo "  $0 <crd> down <to>"
+  echo
+  echo "Valid CRDs: ${VALID_CRDS[*]}"
+  echo "(crd defaults to '${DEFAULT_CRD}')"
+}
+
+# Validate CRD
+if ! is_valid_crd "$CRD"; then
+  echo "❌ Unknown CRD '$CRD'"
+  print_help
+  exit 1
+fi
+
+# Validate command
+if [[ "$CMD" != "up" && "$CMD" != "down" ]]; then
+  echo "❌ Unknown command '$CMD'"
+  print_help
+  exit 1
+fi
+
+# Emit correct spec for each CRD
+emit_spec() {
+  case "$1" in
+    loader|processor|ingestor)
+      cat <<EOF
+spec:
+  image: nginx
+  replicas: 1
+EOF
+      ;;
+    auditor)
+      cat <<EOF
+spec:
+  auditMode: "standard"
+EOF
+      ;;
+  esac
+}
+
+case "$CMD" in
+up)
+  COUNT="${ARG:-200}"
+  echo "→ Creating ${CRD}-1 through ${CRD}-${COUNT}"
+  for i in $(seq 1 "$COUNT"); do
+    kubectl apply -f - <<EOF
+apiVersion: autoscale.orkestra.io/v1alpha1
+kind: ${CRD^}
+metadata:
+  name: ${CRD}-$i
+  labels:
+    orkestra.load: "true"
+$(emit_spec "$CRD")
+EOF
+  done
+  echo "✔ Created ${COUNT} ${CRD^} resources"
+  ;;
+
+down)
+  TO="${ARG:-0}"
+  MAX="${4:-500}"
+  echo "→ Deleting ${CRD}-$((TO+1)) through ${CRD}-${MAX}"
+  for i in $(seq 1 "$MAX"); do
+    kubectl delete "$CRD" "${CRD}-$i" --ignore-not-found --wait=false || true
+  done
+  wait
+  echo "✔ Scaled down to ${TO} ${CRD^} resources"
+  ;;
+esac
diff --git a/pkg/autoscaler/autoscale_worker_info.go b/pkg/autoscaler/autoscale_worker_info.go
index e897556b..54afee6c 100644
--- a/pkg/autoscaler/autoscale_worker_info.go
+++ b/pkg/autoscaler/autoscale_worker_info.go
@@ -61,6 +61,12 @@ type WorkerInfo struct {
 
 	// BusyPercent is InFlight/Effective as a percentage. Useful for UI gauges.
 	BusyPercent float64 `json:"busyPercent"`
+
+	// ResyncEffective is the current resync interval (baseline or override).
+	ResyncEffective string `json:"resyncEffective"`
+
+	// ResyncConfigured is the baseline resync from the CRD entry.
+	ResyncConfigured string `json:"resyncConfigured"`
 }
 
 // BuildWorkerInfo constructs the WorkerInfo from the live operatorbox state.
@@ -70,6 +76,7 @@ func BuildWorkerInfo(
 	metrics *AutoMetrics,
 	configured int,
 	configuredQueueDepth int,
+	configuredResync string,
 	maxWorkers int,
 	autoscalerEnabled bool,
 	autoscalerState *autoscalerStateSnapshot,
@@ -91,6 +98,8 @@ func BuildWorkerInfo(
 		Max:                  maxWorkers,
 		AutoscalerEnabled:    autoscalerEnabled,
 		QueueDepth:           queueDepth,
+		ResyncConfigured:     configuredResync,
+		ResyncEffective:      configuredResync, // updated below if override active
 		QueueDepthConfigured: configuredQueueDepth,
 		QueueDepthEffective:  configuredQueueDepth, // updated below if override active
 		BusyPercent:          sem.BusyPercent(),
@@ -100,6 +109,7 @@ func BuildWorkerInfo(
 		info.OverrideActive = true
 		info.OverrideWorkers = autoscalerState.EffectiveWorkers
 		info.QueueDepthEffective = autoscalerState.EffectiveQueueDepth
+		info.ResyncEffective = autoscalerState.EffectiveResync
 	}
 
 	return info
@@ -111,6 +121,7 @@ type autoscalerStateSnapshot struct {
 	OverrideActive      bool
 	EffectiveWorkers    int
 	EffectiveQueueDepth int
+	EffectiveResync     string
 }
 
 // Snapshot returns a point-in-time snapshot of the Autoscaler's state.
@@ -120,7 +131,8 @@ func (a *Autoscaler) Snapshot() *autoscalerStateSnapshot {
 		return nil
 	}
 	workers := a.baseline.Workers
-	qdepth := a.baseline.QueueDepth
+	qdepth := a.baseline.MaxQueueDepth
+	resync := a.baseline.Resync
 	overrideActive := a.state.OverrideActive
 
 	if overrideActive {
@@ -130,11 +142,15 @@ func (a *Autoscaler) Snapshot() *autoscalerStateSnapshot {
 		if a.spec.Do.QueueDepth != nil {
 			qdepth = *a.spec.Do.QueueDepth
 		}
+		if a.spec.Do.Resync != nil {
+			resync = a.spec.Do.Resync.Duration
+		}
 	}
 
 	return &autoscalerStateSnapshot{
 		OverrideActive:      overrideActive,
 		EffectiveWorkers:    workers,
 		EffectiveQueueDepth: qdepth,
+		EffectiveResync:     resync.String(),
 	}
 }
diff --git a/pkg/autoscaler/autoscaler.go b/pkg/autoscaler/autoscaler.go
index a69f1787..0783d793 100644
--- a/pkg/autoscaler/autoscaler.go
+++ b/pkg/autoscaler/autoscaler.go
@@ -244,7 +244,7 @@ func (a *Autoscaler) applyOverride() {
 // restoreBaseline restores the CRD's declared configuration.
 func (a *Autoscaler) restoreBaseline() {
 	a.target.ResizeWorkers(a.baseline.Workers)
-	a.target.SetQueueDepthLimit(a.baseline.QueueDepth)
+	a.target.SetQueueDepthLimit(a.baseline.MaxQueueDepth)
 	// Pass 0 for resync: the informer's built-in resync handles the baseline
 	// cadence. 0 idles the autoscaler resync goroutine so it does not add a
 	// redundant second trigger on top of the informer's own period.
@@ -256,7 +256,7 @@ func (a *Autoscaler) restoreBaseline() {
 	logger.Info().
 		Str("crd", a.crdKind).
 		Int("workers", a.baseline.Workers).
-		Int("queueDepth", a.baseline.QueueDepth).
+		Int("queueDepth", a.baseline.MaxQueueDepth).
 		Dur("resync", a.baseline.Resync).
 		Msg("autoscaler: baseline restored")
 }
diff --git a/pkg/informer/type.go b/pkg/informer/type.go
index 924ec786..df5a8ab1 100644
--- a/pkg/informer/type.go
+++ b/pkg/informer/type.go
@@ -95,7 +95,7 @@ func SharedInformerFactory(
 		defaultWq:        defaultWq,
 		namespace:        kfg.Cluster().Namespace,
 		scheme:           scheme,
-		defaultResync:    kfg.Cluster().DefaultResync,
+		defaultResync:    kfg.Katalog().DefaultResync,
 		informers:        make(map[string]*InformerEntry),
 		missing:          make(map[string]*InformerEntry),
 		ready:            make(chan struct{}),
diff --git a/pkg/katalog/autoscale_profile_types.go b/pkg/katalog/autoscale_profile_types.go
new file mode 100644
index 00000000..f14f34f8
--- /dev/null
+++ b/pkg/katalog/autoscale_profile_types.go
@@ -0,0 +1,83 @@
+// Package katalog defines shared types used by autoscale profile expansion.
+//
+// ProfileConfig describes the static, pre-runtime configuration for an
+// autoscale profile. Profiles are computed presets that:
+//   - define how thresholds relate to maxQueueDepth
+//   - define how worker and queueDepth overrides scale from baseline
+//   - define interval and cooldown defaults
+//
+// These values are used during katalog load to expand a profile into a full
+// AutoscaleSpec. The autoscaler runtime never sees profiles — only the fully
+// expanded spec.
+
+package katalog
+
+import "time"
+
+// ProfileConfig defines the knobs for a single autoscale profile.
+//
+// QueueThresholdPct:
+//
+//	Percentage of maxQueueDepth at which scaling should trigger.
+//	Example: 0.60 means "scale when queueDepth exceeds 60% of maxQueueDepth".
+//
+// WorkerMultiplier:
+//
+//	Multiplier applied to baseline workers to compute the override.
+//
+// QueueMultiplier:
+//
+//	Multiplier applied to baseline queueDepth to compute the override.
+//
+// Interval / Cooldown:
+//
+//	Default evaluation and cooldown windows for the profile.
+type ProfileConfig struct {
+	QueueThresholdPct float64
+	WorkerMultiplier  float64
+	QueueMultiplier   float64
+	Interval          time.Duration
+	Cooldown          time.Duration
+}
+
+// profileConfig maps each AutoscaleProfile to its static configuration.
+//
+// These values are intentionally simple and predictable. They scale relative to
+// maxQueueDepth (for thresholds) and baseline values (for overrides).
+var profileConfig = map[AutoscaleProfile]ProfileConfig{
+	AutoscaleBurst: {
+		QueueThresholdPct: 0.60, // scale at 60% of maxQueueDepth
+		WorkerMultiplier:  4.0,
+		QueueMultiplier:   10.0,
+		Interval:          5 * time.Second,
+		Cooldown:          30 * time.Second,
+	},
+	AutoscaleSteady: {
+		QueueThresholdPct: 0.40,
+		WorkerMultiplier:  2.0,
+		QueueMultiplier:   3.0,
+		Interval:          30 * time.Second,
+		Cooldown:          2 * time.Minute,
+	},
+	AutoscaleBatch: {
+		QueueThresholdPct: 1.00, // unused (cron-based)
+		WorkerMultiplier:  3.0,
+		QueueMultiplier:   8.0,
+		Interval:          60 * time.Second,
+		Cooldown:          5 * time.Minute,
+	},
+	AutoscaleLatencySensitive: {
+		QueueThresholdPct: 0.00, // unused (latency-based)
+		WorkerMultiplier:  2.5,
+		QueueMultiplier:   1.0, // no queue override
+		Interval:          15 * time.Second,
+		Cooldown:          1 * time.Minute,
+	},
+	AutoscaleCostOptimized: {
+		QueueThresholdPct: 0.80,
+		WorkerMultiplier:  0.5,
+		QueueMultiplier:   0.5,
+		Interval:          30 * time.Second,
+		Cooldown:          10 * time.Minute,
+	},
+}
diff --git a/pkg/katalog/autoscaler_profile.go b/pkg/katalog/autoscaler_profile.go
index 458a63b8..7300d2cf 100644
--- a/pkg/katalog/autoscaler_profile.go
+++ b/pkg/katalog/autoscaler_profile.go
@@ -6,7 +6,8 @@
 //
 // Profiles are computed presets. They:
 //   - validate the profile name
-//   - compute thresholds and overrides from baseline values
+//   - compute thresholds relative to maxQueueDepth
+//   - compute worker/queue overrides from baseline values
 //   - apply default interval/cooldown values
 //   - fail fast on unknown profiles
 //
@@ -24,6 +25,7 @@ import (
 	"fmt"
 	"math"
 	"strings"
+	"time"
 
 	orktypes "github.com/orkspace/orkestra/pkg/types"
 )
@@ -42,24 +44,24 @@ const (
 // AutoscaleSpec using the CRD's declared baseline values.
 //
 // This runs BEFORE merge, so the runtime only ever sees a fully-formed spec.
-func ApplyAutoscalerProfile(profile string, baseline orktypes.AutoscaleBaseline) (*orktypes.AutoscaleSpec, error) {
-	switch AutoscaleProfile(strings.ToLower(profile)) {
+func ApplyAutoscalerProfile(profile string, b orktypes.AutoscaleBaseline) (*orktypes.AutoscaleSpec, error) {
+	p := AutoscaleProfile(strings.ToLower(profile))
+	cfg, ok := profileConfig[p]
+	if !ok {
+		return nil, fmt.Errorf("unknown autoscale profile: %q", profile)
+	}
 
+	switch p {
 	case AutoscaleBurst:
-		return expandBurst(baseline), nil
-
+		return expandBurst(b, cfg), nil
 	case AutoscaleSteady:
-		return expandSteady(baseline), nil
-
+		return expandSteady(b, cfg), nil
 	case AutoscaleBatch:
-		return expandBatch(baseline), nil
-
+		return expandBatch(b, cfg), nil
 	case AutoscaleLatencySensitive:
-		return expandLatencySensitive(baseline), nil
-
+		return expandLatencySensitive(b, cfg), nil
 	case AutoscaleCostOptimized:
-		return expandCostOptimized(baseline), nil
-
+		return expandCostOptimized(b, cfg), nil
 	default:
 		return nil, fmt.Errorf("unknown autoscale profile: %q", profile)
 	}
@@ -72,20 +74,23 @@ func ApplyAutoscalerProfile(profile string, baseline orktypes.AutoscaleBaseline)
 //
 // Goal: React instantly to spikes.
 // Strategy:
+//   - threshold = pct(maxQueueDepth)
+//   - workers   = baseline * multiplier
+//   - queue     = baseline * multiplier
 //   - very short interval + cooldown
-//   - threshold = queueDepth * 3
-//   - workers = baseline * 4
-//   - queueDepth = baseline * 10
+//
+// Threshold is computed relative to maxQueueDepth so scaling happens BEFORE
+// items are dropped.
 //
 
-func expandBurst(b orktypes.AutoscaleBaseline) *orktypes.AutoscaleSpec {
-	threshold := int(float64(b.QueueDepth) * 3.0)
-	workers := int(float64(b.Workers) * 4.0)
-	queue := int(float64(b.QueueDepth) * 10.0)
+func expandBurst(b orktypes.AutoscaleBaseline, cfg ProfileConfig) *orktypes.AutoscaleSpec {
+	threshold := int(float64(b.MaxQueueDepth) * cfg.QueueThresholdPct)
+	workers := int(float64(b.Workers) * cfg.WorkerMultiplier)
+	queue := int(float64(b.MaxQueueDepth) * cfg.QueueMultiplier)
 
 	return &orktypes.AutoscaleSpec{
-		Interval: orktypes.Duration{Duration: 5 * 1e9},  // 5s
-		Cooldown: orktypes.Duration{Duration: 30 * 1e9}, // 30s
+		Interval: orktypes.Duration{Duration: cfg.Interval},
+		Cooldown: orktypes.Duration{Duration: cfg.Cooldown},
 		Conditions: orktypes.AutoscaleConditions{
 			When: []orktypes.Condition{
 				{
@@ -108,20 +113,20 @@ func expandBurst(b orktypes.AutoscaleBaseline) *orktypes.AutoscaleSpec {
 //
 // Goal: Smooth, predictable scaling.
 // Strategy:
+//   - threshold = pct(maxQueueDepth)
+//   - workers   = baseline * multiplier
+//   - queue     = baseline * multiplier
 //   - moderate interval + cooldown
-//   - threshold = queueDepth * 1.5
-//   - workers = baseline * 2
-//   - queueDepth = baseline * 3
 //
 
-func expandSteady(b orktypes.AutoscaleBaseline) *orktypes.AutoscaleSpec {
-	threshold := int(float64(b.QueueDepth) * 1.5)
-	workers := int(float64(b.Workers) * 2.0)
-	queue := int(float64(b.QueueDepth) * 3.0)
+func expandSteady(b orktypes.AutoscaleBaseline, cfg ProfileConfig) *orktypes.AutoscaleSpec {
+	threshold := int(float64(b.MaxQueueDepth) * cfg.QueueThresholdPct)
+	workers := int(float64(b.Workers) * cfg.WorkerMultiplier)
+	queue := int(float64(b.MaxQueueDepth) * cfg.QueueMultiplier)
 
 	return &orktypes.AutoscaleSpec{
-		Interval: orktypes.Duration{Duration: 30 * 1e9},  // 30s
-		Cooldown: orktypes.Duration{Duration: 120 * 1e9}, // 2m
+		Interval: orktypes.Duration{Duration: cfg.Interval},
+		Cooldown: orktypes.Duration{Duration: cfg.Cooldown},
 		Conditions: orktypes.AutoscaleConditions{
 			When: []orktypes.Condition{
 				{
@@ -149,23 +154,25 @@ func expandSteady(b orktypes.AutoscaleBaseline) *orktypes.AutoscaleSpec {
 // Goal: Scale during scheduled batch windows.
 // Strategy:
 //   - cron window 23:00 → 02:00
-//   - workers = baseline * 3
-//   - queueDepth = baseline * 8
+//   - workers = baseline * multiplier
+//   - queue   = baseline * multiplier
 //   - long cooldown
 //
+// QueueThresholdPct is unused for batch profiles.
+//
 
-func expandBatch(b orktypes.AutoscaleBaseline) *orktypes.AutoscaleSpec {
-	workers := int(float64(b.Workers) * 3.0)
-	queue := int(float64(b.QueueDepth) * 8.0)
+func expandBatch(b orktypes.AutoscaleBaseline, cfg ProfileConfig) *orktypes.AutoscaleSpec {
+	workers := int(float64(b.Workers) * cfg.WorkerMultiplier)
+	queue := int(float64(b.MaxQueueDepth) * cfg.QueueMultiplier)
 
 	return &orktypes.AutoscaleSpec{
-		Interval: orktypes.Duration{Duration: 60 * 1e9},  // 60s
-		Cooldown: orktypes.Duration{Duration: 300 * 1e9}, // 5m
+		Interval: orktypes.Duration{Duration: cfg.Interval},
+		Cooldown: orktypes.Duration{Duration: cfg.Cooldown},
 		Conditions: orktypes.AutoscaleConditions{
 			AnyOf: []orktypes.Condition{
 				{
 					Cron:     "0 23 * * *",
-					Duration: orktypes.Duration{Duration: 3 * 3600 * 1e9}, // 3h
+					Duration: orktypes.Duration{Duration: 3 * time.Hour},
 				},
 			},
 		},
@@ -183,16 +190,16 @@ func expandBatch(b orktypes.AutoscaleBaseline) *orktypes.AutoscaleSpec {
 //
 // Goal: Keep reconcile latency low.
 // Strategy:
-//   - threshold = 200ms P95
-//   - workers = ceil(baseline * 2.5)
+//   - threshold = 200ms P95 (queue threshold unused)
+//   - workers   = ceil(baseline * multiplier)
 //
 
-func expandLatencySensitive(b orktypes.AutoscaleBaseline) *orktypes.AutoscaleSpec {
-	workers := int(math.Ceil(float64(b.Workers) * 2.5))
+func expandLatencySensitive(b orktypes.AutoscaleBaseline, cfg ProfileConfig) *orktypes.AutoscaleSpec {
+	workers := int(math.Ceil(float64(b.Workers) * cfg.WorkerMultiplier))
 
 	return &orktypes.AutoscaleSpec{
-		Interval: orktypes.Duration{Duration: 15 * 1e9}, // 15s
-		Cooldown: orktypes.Duration{Duration: 60 * 1e9}, // 1m
+		Interval: orktypes.Duration{Duration: cfg.Interval},
+		Cooldown: orktypes.Duration{Duration: cfg.Cooldown},
 		Conditions: orktypes.AutoscaleConditions{
 			When: []orktypes.Condition{
 				{
@@ -214,24 +221,30 @@ func expandLatencySensitive(b orktypes.AutoscaleBaseline) *orktypes.AutoscaleSpe
 //
 // Goal: Minimize resource usage.
 // Strategy:
-//   - workers = max(1, baseline * 0.5)
-//   - queueDepth = baseline * 0.5
+//   - threshold = pct(maxQueueDepth)
+//   - workers   = max(1, baseline * multiplier)
+//   - queue     = baseline * multiplier
 //   - idlePercent > 60
 //
 
-func expandCostOptimized(b orktypes.AutoscaleBaseline) *orktypes.AutoscaleSpec {
-	workers := int(math.Max(1, float64(b.Workers)*0.5))
-	queue := int(float64(b.QueueDepth) * 0.5)
+func expandCostOptimized(b orktypes.AutoscaleBaseline, cfg ProfileConfig) *orktypes.AutoscaleSpec {
+	workers := int(math.Max(1, float64(b.Workers)*cfg.WorkerMultiplier))
+	queue := int(float64(b.MaxQueueDepth) * cfg.QueueMultiplier)
+	threshold := int(float64(b.MaxQueueDepth) * cfg.QueueThresholdPct)
 
 	return &orktypes.AutoscaleSpec{
-		Interval: orktypes.Duration{Duration: 30 * 1e9},  // 30s
-		Cooldown: orktypes.Duration{Duration: 600 * 1e9}, // 10m
+		Interval: orktypes.Duration{Duration: cfg.Interval},
+		Cooldown: orktypes.Duration{Duration: cfg.Cooldown},
 		Conditions: orktypes.AutoscaleConditions{
 			When: []orktypes.Condition{
 				{
 					Field:       "metrics.workersIdlePercent",
 					GreaterThan: "60",
 				},
+				{
+					Field:       "metrics.queueDepth",
+					GreaterThan: fmt.Sprintf("%d", threshold),
+				},
 			},
 		},
 		Do: orktypes.AutoscaleAction{
diff --git a/pkg/katalog/autosclaer_profile_test.go b/pkg/katalog/autosclaer_profile_test.go
index 5a58961e..1e1f751c 100644
--- a/pkg/katalog/autosclaer_profile_test.go
+++ b/pkg/katalog/autosclaer_profile_test.go
@@ -10,9 +10,9 @@ import (
 
 func baseline(workers, queue int, resync time.Duration) orktypes.AutoscaleBaseline {
 	return orktypes.AutoscaleBaseline{
-		Workers:    workers,
-		QueueDepth: queue,
-		Resync:     resync,
+		Workers:       workers,
+		MaxQueueDepth: queue,
+		Resync:        resync,
 	}
 }
 
diff --git a/pkg/katalog/validate.go b/pkg/katalog/validate.go
index 08f16f97..3753b572 100644
--- a/pkg/katalog/validate.go
+++ b/pkg/katalog/validate.go
@@ -226,12 +226,22 @@ func (k *Katalog) setDefaults(kfg *konfig.Konfig) error {
 
 		// Handle Resync
 		if crd.Resync == 0 {
-			crd.Resync = kfg.Cluster().DefaultResync
+			crd.Resync = crd.SetResync(kfg.Katalog().DefaultResync)
 		}
 
 		// Handle Workers
 		if crd.Workers == 0 {
-			crd.Workers = kfg.Cluster().DefaultWorkers
+			crd.Workers = crd.SetWorkers(kfg.Katalog().DefaultWorkers)
+		}
+
+		// Handle QueueDepth
+		if crd.Queue.MaxQueueDepth == 0 {
+			crd.Queue.MaxQueueDepth = crd.SetMaxQueueDepth(kfg.Katalog().DefaultMaxQueueDepth)
+		}
+
+		// Handle QueueDegradeThreshold
+		if crd.Queue.DegradeThreshold == 0 {
+			crd.Queue.DegradeThreshold = crd.SetMaxQueueDepth(kfg.Katalog().DefaultDegradeThreshold)
 		}
 
 		// Handle Notifications
diff --git a/pkg/katalog/validation_autoscale.go b/pkg/katalog/validation_autoscale.go
index 49a50fc8..991b267d 100644
--- a/pkg/katalog/validation_autoscale.go
+++ b/pkg/katalog/validation_autoscale.go
@@ -74,9 +74,9 @@ func (k *Katalog) validateAutoscaleProfile() error {
 		// Expand the profile into a fully-formed AutoscaleSpec using the CRD's
 		// declared workers and queue depth as the baseline.
 		baseline := orktypes.AutoscaleBaseline{
-			Workers:    crd.Workers,
-			QueueDepth: crd.Queue.MaxQueueDepth,
-			Resync:     crd.Resync,
+			Workers:       crd.Workers,
+			MaxQueueDepth: crd.Queue.MaxQueueDepth,
+			Resync:        crd.Resync,
 		}
 		expanded, err := ApplyAutoscalerProfile(profile, baseline)
 		if err != nil {
diff --git a/pkg/konfig/konfig.go b/pkg/konfig/konfig.go
index 4c1b45bb..7044f784 100644
--- a/pkg/konfig/konfig.go
+++ b/pkg/konfig/konfig.go
@@ -25,12 +25,6 @@ func Init(filenames ...string) (*Konfig, error) {
 			MasterURL: GetStrEnv("MASTER_URL", ""),
 			Name:      GetStrEnv("CLUSTER_NAME", "orkestra-cluster"),
 			Namespace: ns,
-
-			// Workload
-			DefaultResync:       GetDurEnvSeconds("DEFAULT_RESYNC", 15),
-			DefaultWorkers:      GetIntEnv("DEFAULT_WORKERS", 3),
-			ShutdownTimeout:     GetDurEnvSeconds("SHUTDOWN_TIMEOUT", 30),
-			ShutdownGracePeriod: GetDurEnvSeconds("SHUTDOWN_GRACE_PERIOD", 60),
 		},
 		// ── Unified security configuration ───────────────────────────────────
 		// ENV vars populate SecurityConfig as defaults.
@@ -126,6 +120,10 @@ func Init(filenames ...string) (*Konfig, error) {
 			DefaultMaxQueueDepth:    GetIntEnv("MAX_QUEUE_DEPTH", 100),
 			DefaultDegradeThreshold: GetIntEnv("DEGRADE_THRESHOLD", 5),
 			Paths:                   GetStrSliceEnv("KATALOG_PATH", []string{}),
+			DefaultResync:           GetDurEnvSeconds("DEFAULT_RESYNC", 15),
+			DefaultWorkers:          GetIntEnv("DEFAULT_WORKERS", 3),
+			ShutdownTimeout:         GetDurEnvSeconds("SHUTDOWN_TIMEOUT", 30),
+			ShutdownGracePeriod:     GetDurEnvSeconds("SHUTDOWN_GRACE_PERIOD", 60),
 		},
 	}
 
diff --git a/pkg/konfig/type.go b/pkg/konfig/type.go
index c16c5125..005a6267 100644
--- a/pkg/konfig/type.go
+++ b/pkg/konfig/type.go
@@ -35,12 +35,6 @@ type clusterKonfig struct {
 	MasterURL      string
 	Name           string
 	Namespace      string `validate:"required"`
-
-	// Worload specific
-	DefaultResync       time.Duration
-	DefaultWorkers      int
-	ShutdownTimeout     time.Duration
-	ShutdownGracePeriod time.Duration
 }
 
 type registryConfig struct {
@@ -139,6 +133,10 @@ type katalogKonfig struct {
 	Paths                   []string // Comma separated Paths to CRD katalog YAML file
 	DefaultMaxQueueDepth    int
 	DefaultDegradeThreshold int `validate:"required"`
+	DefaultResync           time.Duration
+	DefaultWorkers          int
+	ShutdownTimeout         time.Duration
+	ShutdownGracePeriod     time.Duration
 }
 
 type konductorElection struct {
diff --git a/pkg/kordinator/crd_health_handers.go b/pkg/kordinator/crd_health_handers.go
index 3f3f5372..9a668af4 100644
--- a/pkg/kordinator/crd_health_handers.go
+++ b/pkg/kordinator/crd_health_handers.go
@@ -305,6 +305,44 @@ func BuildCRDInfoHandler(
 			autoMetrics = nil
 		}
 
+		// When autoscaler is enabled, use WorkerInfo as the authoritative source
+		// for all worker and queue fields — the legacy health counters only track
+		// the initial configured pool and go negative when extra workers spawn.
+		wi := h.GetWorkerInfo()
+		workers := v.workers
+		workersActive := h.GetActiveWorkers()
+		workersIdle := h.GetIdleWorkers()
+		workersProcessing := h.GetProcessingWorkers()
+		workersSource := v.workersSource
+		queueDepth := h.QueueDepth(crd.GVK().String())
+		maxQueueDepth := v.maxQueueDepth
+		maxQueueDepthSource := v.maxQueueDepthSource
+		resync := v.resync
+		resyncSource := v.resyncSource
+
+		autoscalerSource := "autoscaler"
+		if wi != nil {
+			// workers — wi is always authoritative: legacy counters go negative when
+			// autoscale spawns extra goroutines beyond the initial configured pool.
+			workers = wi.Configured
+			workersActive = int32(wi.Effective)
+			workersIdle = int32(wi.Idle)
+			workersProcessing = int32(wi.InFlight)
+			queueDepth = int(wi.QueueDepth)
+
+			// queue limit and resync — only override when autoscaler is actively
+			// applying an override. Baseline values come from resolveCRDDisplayValues
+			// which includes the konfig default fallback (e.g. 100 queue depth).
+			if wi.OverrideActive {
+				maxQueueDepth = int(wi.QueueDepthEffective)
+				resync = wi.ResyncEffective
+
+				maxQueueDepthSource = autoscalerSource
+				resyncSource = autoscalerSource
+				workersSource = autoscalerSource
+			}
+		}
+
 		response := CRDInfoResponse{
 			Name:                crd.Name,
 			Description:         crd.Description,
@@ -314,17 +352,17 @@ func BuildCRDInfoHandler(
 			Namespaced:          crd.IsNamespaced(),
 			Namespace:           crd.Namespace,
 			DependsOn:           crd.DependsOn.Names(),
-			Workers:             v.workers,
-			WorkersActive:       h.GetActiveWorkers(),
-			WorkersIdle:         h.GetIdleWorkers(),
-			WorkersProcessing:   h.GetProcessingWorkers(),
+			Workers:             workers,
+			WorkersActive:       workersActive,
+			WorkersIdle:         workersIdle,
+			WorkersProcessing:   workersProcessing,
 			WorkerDetails:       h.GetWorkerStates(),
-			WorkersSource:       v.workersSource,
-			Resync:              v.resync,
-			ResyncSource:        v.resyncSource,
-			QueueDepth:          h.QueueDepth(crd.GVK().String()),
-			MaxQueueDepth:       v.maxQueueDepth,
-			MaxQueueDepthSource: v.maxQueueDepthSource,
+			WorkersSource:       workersSource,
+			Resync:              resync,
+			ResyncSource:        resyncSource,
+			QueueDepth:          queueDepth,
+			MaxQueueDepth:       maxQueueDepth,
+			MaxQueueDepthSource: maxQueueDepthSource,
 			ResourceCount:       v.resourceCount,
 			TotalReconciles:     h.TotalReconciles(),
 			OperatorBox:         operatorBoxInfoStruct(crd),
@@ -334,7 +372,7 @@ func BuildCRDInfoHandler(
 			ErrorRate:           h.ErrorRatePercent(),
 			RBAC:                rbacInfo,
 			AutoscalerEnabled:   crd.AutoscaleEnabled(),
-			AutoscalerWorkers:   h.GetWorkerInfo(),
+			AutoscalerWorkers:   wi,
 			Metrics:             autoMetrics,
 		}
 
@@ -843,14 +881,14 @@ func resolveCRDDisplayValues(
 	resyncSource := "configured"
 	if crd.Resync == 0 {
 		resyncSource = "default"
-		resync = kfg.Cluster().DefaultResync.String()
+		resync = kfg.Katalog().DefaultResync.String()
 	}
 
 	// Workers
 	workers := crd.Workers
 	workersSource := "configured"
 	if crd.Workers == 0 {
-		workers = kfg.Cluster().DefaultWorkers
+		workers = kfg.Katalog().DefaultWorkers
 		workersSource = "default"
 	}
 
diff --git a/pkg/kordinator/dependency_kordinator.go b/pkg/kordinator/dependency_kordinator.go
index 59b96e87..d81ee929 100644
--- a/pkg/kordinator/dependency_kordinator.go
+++ b/pkg/kordinator/dependency_kordinator.go
@@ -451,7 +451,7 @@ type autoMetricsExporter interface {
 // workerInfoProvider is a local interface for reading a live WorkerInfo snapshot
 // from a reconciler. Used to populate the /katalog/{crd} handler response.
 type workerInfoProvider interface {
-	WorkerInfo(configuredWorkers, configuredQueueDepth int) *ork_autoscaler.WorkerInfo
+	WorkerInfo(configuredResync string, configuredWorkers, configuredQueueDepth int) *ork_autoscaler.WorkerInfo
 }
 
 // rollbackNotifierSetter is a local interface for injecting CRDHealth rollback
@@ -534,7 +534,7 @@ func (k *DependencyKordinator) startCRDWorkers(ctx context.Context, gvk string,
 	// live concurrency metrics without importing the reconciler package.
 	if wip, ok := rec.(workerInfoProvider); ok {
 		k.crdHealthMap[gvk].SetWorkerInfoFn(func() *ork_autoscaler.WorkerInfo {
-			info := wip.WorkerInfo(workers, entry.CRD.Queue.MaxQueueDepth)
+			info := wip.WorkerInfo(entry.CRD.Resync.String(), workers, entry.CRD.Queue.MaxQueueDepth)
 			return info
 		})
 	}
diff --git a/pkg/reconciler/generic.go b/pkg/reconciler/generic.go
index f1c00992..0e23cc89 100644
--- a/pkg/reconciler/generic.go
+++ b/pkg/reconciler/generic.go
@@ -181,9 +181,9 @@ func NewGenericReconciler[PTR domain.Object](
 
 	if crd.AutoscaleEnabled() {
 		baseline := orktypes.AutoscaleBaseline{
-			Workers:    workers,
-			QueueDepth: crd.Queue.MaxQueueDepth,
-			Resync:     crd.Resync,
+			Workers:       workers,
+			MaxQueueDepth: crd.Queue.MaxQueueDepth,
+			Resync:        crd.Resync,
 		}
 		r.autoscaler = autoscaler.NewAutoscaler(
 			crd.APITypes.Kind,
diff --git a/pkg/reconciler/generic_autoscale.go b/pkg/reconciler/generic_autoscale.go
index 938670e8..22c7ae68 100644
--- a/pkg/reconciler/generic_autoscale.go
+++ b/pkg/reconciler/generic_autoscale.go
@@ -101,7 +101,7 @@ func (r *GenericReconciler[PTR]) GetAutoMetrics() *autoscaler.AutoMetrics {
 
 // WorkerInfo returns a live WorkerInfo snapshot for the /katalog/{crd} endpoint.
 // configuredWorkers and configuredQueueDepth come from the CRD entry at startup.
-func (r *GenericReconciler[PTR]) WorkerInfo(configuredWorkers, configuredQueueDepth int) *autoscaler.WorkerInfo {
+func (r *GenericReconciler[PTR]) WorkerInfo(configuredResync string, configuredWorkers, configuredQueueDepth int) *autoscaler.WorkerInfo {
 	maxWorkers := configuredWorkers
 	if r.autoscaler != nil {
 		if snap := r.autoscaler.Snapshot(); snap != nil && snap.EffectiveWorkers > maxWorkers {
@@ -113,6 +113,7 @@ func (r *GenericReconciler[PTR]) WorkerInfo(configuredWorkers, configuredQueueDe
 		r.autoMetrics,
 		configuredWorkers,
 		configuredQueueDepth,
+		configuredResync,
 		maxWorkers,
 		r.autoscaler != nil,
 		r.autoscaler.Snapshot(),
diff --git a/pkg/types/autoscale.go b/pkg/types/autoscale.go
index ec96da99..58ac18d8 100644
--- a/pkg/types/autoscale.go
+++ b/pkg/types/autoscale.go
@@ -111,9 +111,9 @@ type AutoscaleAction struct {
 // AutoscaleBaseline captures the CRD's declared configuration before any
 // autoscale override is applied. Always restored when conditions are false.
 type AutoscaleBaseline struct {
-	Workers    int
-	QueueDepth int
-	Resync     time.Duration
+	Workers       int
+	MaxQueueDepth int
+	Resync        time.Duration
 }
 
 // AutoscaleState tracks the runtime state of the autoscaler for one operatorbox.
diff --git a/pkg/types/methods.go b/pkg/types/methods.go
index 0636b735..df678436 100644
--- a/pkg/types/methods.go
+++ b/pkg/types/methods.go
@@ -3,6 +3,7 @@ package types
 import (
 	"fmt"
 	"strings"
+	"time"
 
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
@@ -65,6 +66,15 @@ func (c *CRDEntry) SetWorkers(def int) int {
 	return c.Workers
 }
 
+// SetResync resolves the resync period for this CRD. If a per‑CRD non‑zero value is
+// set, it is used; otherwise the global default resync is applied.
+func (c *CRDEntry) SetResync(def time.Duration) time.Duration {
+	if c.Resync != 0 {
+		return c.Resync
+	}
+	return def
+}
+
 // IsDynamic determines whether this CRD should operate in dynamic mode.
 // Resolution order (first match wins):
 //  1. mode: dynamic explicitly declared → true

From cc639574b6934f05d9f7ca05f291fdfffb24f38f Mon Sep 17 00:00:00 2001
From: ialexeze <ialexeze@gmail.com>
Date: Wed, 13 May 2026 12:03:55 +0000
Subject: [PATCH 2/3] test done

---
 .../01-without-autoscaler/katalog.yaml        |   4 +
 .../02-based-on-own-metrics/katalog.yaml      |   4 +
 .../03-sibling-in-binary/README.md            |   1 -
 .../03-sibling-in-binary/katalog.yaml         |  24 +--
 .../04-sibling-in-cluster/README.md           | 176 ++++++++++++++++++
 .../04-sibling-in-cluster/cleanup.sh          |  14 ++
 .../04-sibling-in-cluster/cr-loader.yaml      |   8 +
 .../04-sibling-in-cluster/cr-processor.yaml   |   8 +
 .../04-sibling-in-cluster/crd-loader.yaml     |  46 +++++
 .../04-sibling-in-cluster/crd-processor.yaml  |  49 +++++
 .../04-sibling-in-cluster/katalog-loader.yaml |  40 ++++
 .../katalog-processor.yaml}                   |  54 ++----
 .../04-sibling-in-cluster/load.sh             | 122 ++++++++++++
 .../katalog.yaml                              |   4 +-
 pkg/autoscaler/autoscale_metrics.go           |   1 +
 pkg/informer/docs/02-namespace-filter.md      |   2 +-
 pkg/kordinator/crd_health_handers.go          |  10 +-
 .../template/resolver_data.go                 |  70 ++++++-
 pkg/reconciler/generic.go                     |  15 +-
 pkg/reconciler/ptr_hooks.go                   |   2 +-
 pkg/reconciler/run_foreach.go                 | 110 +++++------
 pkg/reconciler/run_template_reconcile.go      |  20 +-
 22 files changed, 648 insertions(+), 136 deletions(-)
 create mode 100644 examples/advanced/12-autoscale/04-sibling-in-cluster/README.md
 create mode 100755 examples/advanced/12-autoscale/04-sibling-in-cluster/cleanup.sh
 create mode 100644 examples/advanced/12-autoscale/04-sibling-in-cluster/cr-loader.yaml
 create mode 100644 examples/advanced/12-autoscale/04-sibling-in-cluster/cr-processor.yaml
 create mode 100644 examples/advanced/12-autoscale/04-sibling-in-cluster/crd-loader.yaml
 create mode 100644 examples/advanced/12-autoscale/04-sibling-in-cluster/crd-processor.yaml
 create mode 100644 examples/advanced/12-autoscale/04-sibling-in-cluster/katalog-loader.yaml
 rename examples/advanced/12-autoscale/{03-sibling-in-cluster/katalog.yaml => 04-sibling-in-cluster/katalog-processor.yaml} (55%)
 create mode 100755 examples/advanced/12-autoscale/04-sibling-in-cluster/load.sh
 rename examples/advanced/12-autoscale/{04-external-friend => 05-external-friend}/katalog.yaml (97%)

diff --git a/examples/advanced/12-autoscale/01-without-autoscaler/katalog.yaml b/examples/advanced/12-autoscale/01-without-autoscaler/katalog.yaml
index b2a6d5dd..2e498f68 100644
--- a/examples/advanced/12-autoscale/01-without-autoscaler/katalog.yaml
+++ b/examples/advanced/12-autoscale/01-without-autoscaler/katalog.yaml
@@ -26,6 +26,10 @@ spec:
           fields:
             - path: phase
               value: "Running"
+            - path: autoscaleActive
+              value: "{{ .metrics.autoscaleActive }}"
+            - path: workers
+              value: "{{ .metrics.workers }}"
 
         onCreate:
           deployments:
diff --git a/examples/advanced/12-autoscale/02-based-on-own-metrics/katalog.yaml b/examples/advanced/12-autoscale/02-based-on-own-metrics/katalog.yaml
index c2ea6e98..89a655f4 100644
--- a/examples/advanced/12-autoscale/02-based-on-own-metrics/katalog.yaml
+++ b/examples/advanced/12-autoscale/02-based-on-own-metrics/katalog.yaml
@@ -39,6 +39,10 @@ spec:
           fields:
             - path: phase
               value: "Running"
+            - path: autoscaleActive
+              value: "{{ .metrics.autoscaleActive }}"
+            - path: workers
+              value: "{{ .metrics.workers }}"
 
         onCreate:
           deployments:
diff --git a/examples/advanced/12-autoscale/03-sibling-in-binary/README.md b/examples/advanced/12-autoscale/03-sibling-in-binary/README.md
index 8feeddf0..17958e1e 100644
--- a/examples/advanced/12-autoscale/03-sibling-in-binary/README.md
+++ b/examples/advanced/12-autoscale/03-sibling-in-binary/README.md
@@ -151,7 +151,6 @@ Observe:
 - Once queue hits **75+ for 30s**, Auditor autoscaler activates  
 - Auditor workers scale **1 → 4**  
 - Auditor resync tightens **60s → 15s**  
-- Loader begins dropping items once queue hits its limit (75)  
 - Processor remains unaffected  
 
 This demonstrates **cross‑CRD autoscaling** using sibling metrics.
diff --git a/examples/advanced/12-autoscale/03-sibling-in-binary/katalog.yaml b/examples/advanced/12-autoscale/03-sibling-in-binary/katalog.yaml
index 4153e470..bf20186f 100644
--- a/examples/advanced/12-autoscale/03-sibling-in-binary/katalog.yaml
+++ b/examples/advanced/12-autoscale/03-sibling-in-binary/katalog.yaml
@@ -10,8 +10,8 @@ metadata:
     Loader produces work. Two downstream CRDs consume it:
 
     Processor  — uses profile: burst. The profile expands into a complete
-                 autoscale config (4× workers, 10× queue depth, 5 s evaluation,
-                 30 s cooldown). Orkestra derives the trigger from the profile's
+                 autoscale config (4x workers, 10x queue depth, 5s evaluation,
+                 30s cooldown). Orkestra derives the trigger from the profile's
                  heuristics. You declare intent; Orkestra computes the parameters.
 
     Auditor    — uses explicit conditions. Watches Loader's live queue depth
@@ -86,10 +86,10 @@ spec:
           fields:
             - path: phase
               value: "Running"
-            # - path: autoscaleActive
-            #   value: "{{ .metrics.autoscaleActive }}"
-            # - path: workers
-            #   value: "{{ .metrics.workers }}"
+            - path: autoscaleActive
+              value: "{{ .metrics.autoscaleActive }}"
+            - path: workers
+              value: "{{ .metrics.workers }}"
 
         onCreate:
           deployments:
@@ -115,12 +115,6 @@ spec:
       resync: 60s
 
       operatorBox:
-        # cross:
-        #   - crd: loader
-        #     selector:
-        #       name: "{{ .metadata.name }}"
-        #       namespace: "{{ .metadata.namespace }}"
-        #     as: loader
         autoscale:
           interval: 30s
           cooldown: 5m
@@ -136,8 +130,10 @@ spec:
           fields:
             - path: phase
               value: "Running"
-            # - path: autoscaleActive
-            #   value: "{{ .metrics.autoscaleActive }}"
+            - path: autoscaleActive
+              value: "{{ .metrics.autoscaleActive }}"
+            - path: workers
+              value: "{{ .metrics.workers }}"
 
         onCreate:
           configMaps:
diff --git a/examples/advanced/12-autoscale/04-sibling-in-cluster/README.md b/examples/advanced/12-autoscale/04-sibling-in-cluster/README.md
new file mode 100644
index 00000000..b706955d
--- /dev/null
+++ b/examples/advanced/12-autoscale/04-sibling-in-cluster/README.md
@@ -0,0 +1,176 @@
+# 04 — Autoscale: Sibling‑in‑Cluster
+
+This example builds on **[03-sibling-in-binary](../03-sibling-in-binary/README.md)**.  
+It reuses the same CRDs and workload logic, but runs **two independent Orkestra runtimes** in **two namespaces** inside the same cluster.
+
+This demonstrates:
+
+- **Cross‑binary autoscaling**  
+- **Cross‑namespace autoscaling**  
+- **Cross‑operator metric sharing**  
+- **Multi‑runtime Control Center aggregation**
+
+---
+
+## What You Learn
+
+- How multi‑runtime aggregation works in the Control Center  
+- How **autoscale profiles** expand into full autoscale specs  
+- How **multiple CRDs in separate binaries** autoscale independently  
+- How to use **cross.\<crd\>.metrics.\*** to read sibling metrics across binaries  
+- How **profile‑based autoscaling** differs from **explicit autoscaling**  
+- How downstream CRDs (Processor, Auditor) react differently to upstream Loader pressure  
+- How Orkestra performs **cross‑runtime dependency scaling** with no restarts, no redeployments, and no external metrics  
+- How the Control Center visualizes **baseline vs override** across multiple runtimes  
+
+---
+
+## Prerequisites
+
+- Ork CLI  
+- Kubernetes cluster (Kind recommended)
+
+Install Ork CLI:
+
+```bash
+curl get.orkestra.sh | bash
+```
+
+Create a Kind cluster and run the first runtime:
+
+```bash
+ORKESTRA_NAMESPACE=loader-system ork run -f katalog-loader.yml --dev
+```
+
+This:
+
+- creates a Kind cluster named `orkestra-playground`
+- runs Orkestra in namespace `loader-system`
+- exposes Control Center on port `8080`
+
+Run the second runtime:
+
+```bash
+ORKESTRA_NAMESPACE=processor-system ORKESTRA_PORT=8090 ork run -f katalog-processor.yaml
+```
+
+This runs a second Orkestra instance in `processor-system` on port `8090`.
+
+Start the Control Center:
+
+```bash
+ork control start -u localhost:8080,localhost:8090
+```
+
+This registers **both runtimes** at startup.
+
+Visit: **http://localhost:8081**
+
+---
+
+## Run the Example
+
+### 1. Apply the CRDs
+
+```bash
+kubectl apply -f crd-loader.yaml
+kubectl apply -f crd-processor.yaml
+```
+
+### 2. Apply the CRs
+
+```bash
+kubectl apply -f cr-loader.yaml
+kubectl apply -f cr-processor.yaml
+```
+
+In the Control Center, you will see two runtimes:
+
+- `loader-autoscale-sibling-in-cluster`
+- `processor-autoscale-sibling-in-cluster`
+
+Open each in separate tabs to watch:
+
+- Loader generating work  
+- Processor autoscaling based on Loader’s queue depth  
+
+> **Note:**  
+> Loader (in `loader-system`) has **no autoscaler**.  
+> Processor (in `processor-system`) autoscale **based on Loader’s queue depth** via `cross.loader.metrics.queueDepth`.
+
+---
+
+## Load the Loader (Cross‑Binary Autoscale)
+
+```bash
+./load.sh loader up 100
+```
+
+Observe:
+
+- Loader queue grows  
+- Once queue hits **60% of Processor’s override queueDepth** for the full **5s interval**, Processor autoscaler activates  
+- Processor workers scale **2 → 8**  
+- Processor queueDepth scales **100 → 1000**  
+
+### Expected logs in `processor-system`
+
+```json
+{"level":"info","crd":"autoscale.orkestra.io/v1alpha1, Kind=Processor","workers":8,"message":"autoscaler: worker pool resized"}
+{"level":"info","crd":"autoscale.orkestra.io/v1alpha1, Kind=Processor","queueDepth":1000,"message":"autoscaler: queue depth limit updated"}
+```
+
+This is **cross‑binary autoscaling** using the standard Orkestra metrics API.
+
+### What Processor is reading:
+
+```json
+// curl -sSL http://localhost:8080/katalog/loader | jq .metrics
+{
+  "errorRatePercent": 0,
+  "queueDepth": 98,
+  "reconcileDurationP95Ms": 1244.18,
+  "workersBusyPercent": 100,
+  "workersIdlePercent": 0
+}
+```
+
+Processor sees Loader’s queue depth **live**, across namespaces, across binaries.
+
+---
+
+## Reduce the Load
+
+```bash
+./load.sh loader down 10
+```
+
+Notes:
+
+- Loader queue drains gradually  
+- Processor stays scaled up until Loader queue remains **below threshold** for the full **30s cooldown**  
+- After cooldown, Processor returns to baseline (2 workers, queueDepth 100)
+
+### Expected logs
+
+```json
+{"level":"info","crd":"autoscale.orkestra.io/v1alpha1, Kind=Processor","workers":2,"message":"autoscaler: worker pool resized"}
+{"level":"info","crd":"autoscale.orkestra.io/v1alpha1, Kind=Processor","queueDepth":100,"message":"autoscaler: queue depth limit updated"}
+{"level":"info","crd":"Processor","workers":2,"queueDepth":100,"message":"autoscaler: baseline restored"}
+```
+
+This is **cross‑runtime dependency scaling**:
+
+- No restarts  
+- No redeployments  
+- No external metrics  
+- No custom code  
+- Just declarative autoscaling  
+
+---
+
+## Cleanup
+
+```bash
+chmod +x cleanup.sh && ./cleanup.sh
+```
diff --git a/examples/advanced/12-autoscale/04-sibling-in-cluster/cleanup.sh b/examples/advanced/12-autoscale/04-sibling-in-cluster/cleanup.sh
new file mode 100755
index 00000000..fba6e06c
--- /dev/null
+++ b/examples/advanced/12-autoscale/04-sibling-in-cluster/cleanup.sh
@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+set -euo pipefail
+echo "Cleaning up 11-autoscale / 04-sibling-in-Cluster..."
+
+# Delete any load CRs first
+kubectl delete ingestors -l orkestra.load=true --ignore-not-found 2>/dev/null || true
+
+kubectl delete -f cr-loader.yaml  --ignore-not-found
+kubectl delete -f cr-processor.yaml  --ignore-not-found
+
+kubectl delete -f crd-loader.yaml  --ignore-not-found
+kubectl delete -f crd-processor.yaml  --ignore-not-found
+
+echo "✓ Done. Stop 'ork run' with Ctrl+C if still running."
diff --git a/examples/advanced/12-autoscale/04-sibling-in-cluster/cr-loader.yaml b/examples/advanced/12-autoscale/04-sibling-in-cluster/cr-loader.yaml
new file mode 100644
index 00000000..3a2b0680
--- /dev/null
+++ b/examples/advanced/12-autoscale/04-sibling-in-cluster/cr-loader.yaml
@@ -0,0 +1,8 @@
+apiVersion: autoscale.orkestra.io/v1alpha1
+kind: Loader
+metadata:
+  name: my-loader
+  namespace: default
+spec:
+  image: nginx:stable-alpine
+  replicas: 1
\ No newline at end of file
diff --git a/examples/advanced/12-autoscale/04-sibling-in-cluster/cr-processor.yaml b/examples/advanced/12-autoscale/04-sibling-in-cluster/cr-processor.yaml
new file mode 100644
index 00000000..d8609c30
--- /dev/null
+++ b/examples/advanced/12-autoscale/04-sibling-in-cluster/cr-processor.yaml
@@ -0,0 +1,8 @@
+apiVersion: autoscale.orkestra.io/v1alpha1
+kind: Processor
+metadata:
+  name: my-processor
+  namespace: default
+spec:
+  image: nginx:stable-alpine
+  replicas: 1
diff --git a/examples/advanced/12-autoscale/04-sibling-in-cluster/crd-loader.yaml b/examples/advanced/12-autoscale/04-sibling-in-cluster/crd-loader.yaml
new file mode 100644
index 00000000..2012b4a0
--- /dev/null
+++ b/examples/advanced/12-autoscale/04-sibling-in-cluster/crd-loader.yaml
@@ -0,0 +1,46 @@
+apiVersion: apiextensions.k8s.io/v1
+kind: CustomResourceDefinition
+metadata:
+  name: loaders.autoscale.orkestra.io
+spec:
+  group: autoscale.orkestra.io
+  names:
+    kind: Loader
+    plural: loaders
+    singular: loader
+  scope: Namespaced
+  versions:
+    - name: v1alpha1
+      served: true
+      storage: true
+      subresources:
+        status: {}
+      additionalPrinterColumns:
+        - name: Image
+          type: string
+          jsonPath: .spec.image
+        - name: Phase
+          type: string
+          jsonPath: .status.phase
+        - name: Age
+          type: date
+          jsonPath: .metadata.creationTimestamp
+      schema:
+        openAPIV3Schema:
+          type: object
+          properties:
+            spec:
+              type: object
+              required: [image]
+              properties:
+                image:
+                  type: string
+                replicas:
+                  type: integer
+                  default: 1
+                auditMode:
+                  type: string
+                  nullable: true
+            status:
+              type: object
+              x-kubernetes-preserve-unknown-fields: true
diff --git a/examples/advanced/12-autoscale/04-sibling-in-cluster/crd-processor.yaml b/examples/advanced/12-autoscale/04-sibling-in-cluster/crd-processor.yaml
new file mode 100644
index 00000000..10f6ba1b
--- /dev/null
+++ b/examples/advanced/12-autoscale/04-sibling-in-cluster/crd-processor.yaml
@@ -0,0 +1,49 @@
+apiVersion: apiextensions.k8s.io/v1
+kind: CustomResourceDefinition
+metadata:
+  name: processors.autoscale.orkestra.io
+spec:
+  group: autoscale.orkestra.io
+  names:
+    kind: Processor
+    plural: processors
+    singular: processor
+  scope: Namespaced
+  versions:
+    - name: v1alpha1
+      served: true
+      storage: true
+      subresources:
+        status: {}
+      additionalPrinterColumns:
+        - name: Image
+          type: string
+          jsonPath: .spec.image
+        - name: Workers
+          type: integer
+          jsonPath: .status.workers
+        - name: Autoscale
+          type: string
+          jsonPath: .status.autoscaleActive
+        - name: Phase
+          type: string
+          jsonPath: .status.phase
+        - name: Age
+          type: date
+          jsonPath: .metadata.creationTimestamp
+      schema:
+        openAPIV3Schema:
+          type: object
+          properties:
+            spec:
+              type: object
+              required: [image]
+              properties:
+                image:
+                  type: string
+                replicas:
+                  type: integer
+                  default: 1
+            status:
+              type: object
+              x-kubernetes-preserve-unknown-fields: true
diff --git a/examples/advanced/12-autoscale/04-sibling-in-cluster/katalog-loader.yaml b/examples/advanced/12-autoscale/04-sibling-in-cluster/katalog-loader.yaml
new file mode 100644
index 00000000..206fb4f5
--- /dev/null
+++ b/examples/advanced/12-autoscale/04-sibling-in-cluster/katalog-loader.yaml
@@ -0,0 +1,40 @@
+apiVersion: orkestra.orkspace.io/v1
+kind: Katalog
+metadata:
+  name: loader-autoscale-sibling-in-cluster
+  author: orkspace
+  version: 0.1.0
+  description: >
+    Cross-binary autoscaling within the same cluster.
+
+    Loader runs in loader-system under its own Orkestra deployment.
+    Processor runs in processor-system under a separate Orkestra deployment.
+
+spec:
+  crds:
+    # ── Loader (loader-system deployment) ─────────────────────────────────────
+    # Fixed concurrency — this is the load source, not the scaling target.
+    loader:
+      apiTypes:
+        group: autoscale.orkestra.io
+        version: v1alpha1
+        kind: Loader
+        plural: loaders
+
+      workers: 3
+      resync: 60s
+
+      operatorBox:
+        status:
+          fields:
+            - path: phase
+              value: "Running"
+
+        onCreate:
+          deployments:
+            - image: "{{ .spec.image }}"
+              replicas: "{{ .spec.replicas }}"
+              port: 8080
+              reconcile: true
+          services:
+            - port: "8080"
diff --git a/examples/advanced/12-autoscale/03-sibling-in-cluster/katalog.yaml b/examples/advanced/12-autoscale/04-sibling-in-cluster/katalog-processor.yaml
similarity index 55%
rename from examples/advanced/12-autoscale/03-sibling-in-cluster/katalog.yaml
rename to examples/advanced/12-autoscale/04-sibling-in-cluster/katalog-processor.yaml
index fcb91520..cd935f0c 100644
--- a/examples/advanced/12-autoscale/03-sibling-in-cluster/katalog.yaml
+++ b/examples/advanced/12-autoscale/04-sibling-in-cluster/katalog-processor.yaml
@@ -1,58 +1,23 @@
 apiVersion: orkestra.orkspace.io/v1
 kind: Katalog
 metadata:
-  name: autoscale-sibling-in-cluster
+  name: processor-autoscale-sibling-in-cluster
+  author: orkspace
+  version: 0.1.0
   description: >
     Cross-binary autoscaling within the same cluster.
 
-    Loader runs in loader-system under its own Orkestra deployment.
-    Processor runs in processor-system under a separate Orkestra deployment.
-
     Processor autoscales based on Loader's live queue depth — but because
     they are in different processes, Processor uses source.endpoint to fetch
     the metric from Loader's Orkestra REST API instead of reading the
     informer cache directly.
 
-    Responses are cached for 10 s to avoid hammering on every evaluation
-    interval. The autoscale interval is 20 s, so each evaluation reads a
+    Responses are cached for 10s to avoid hammering on every evaluation
+    interval. The autoscale interval is 20s, so each evaluation reads a
     cached value at most twice stale — acceptable for burst-response scaling.
 
-    Deploy order:
-      1. kubectl apply -f katalog.yaml -n loader-system
-      2. kubectl apply -f katalog.yaml -n processor-system
-
-    Trigger load:
-      make load   # creates 100 Loader CRs to fill the queue
-
 spec:
   crds:
-    # ── Loader (loader-system deployment) ─────────────────────────────────────
-    # Fixed concurrency — this is the load source, not the scaling target.
-    loader:
-      apiTypes:
-        group: autoscale.orkestra.io
-        version: v1alpha1
-        kind: Loader
-        plural: loaders
-
-      workers: 3
-      resync: 60s
-
-      operatorBox:
-        status:
-          fields:
-            - path: phase
-              value: "Running"
-
-        onCreate:
-          deployments:
-            - image: "{{ .spec.image }}"
-              replicas: "{{ .spec.replicas }}"
-              port: 8080
-              reconcile: true
-          services:
-            - port: "8080"
-
     # ── Processor (processor-system deployment) ───────────────────────────────
     # Autoscales based on Loader's queue depth fetched via HTTP API.
     # source.endpoint is required because Loader is in a different process.
@@ -73,9 +38,10 @@ spec:
           conditions:
             when:
               - field: cross.loader.metrics.queueDepth
-                greaterThan: "100"
+                greaterThan: "60"
                 source:
-                  endpoint: "http://orkestra.loader-system:8080/katalog/loader/metrics"
+                  # endpoint: "http://orkestra-runtime.loader-system:8080/katalog/loader"  # > if running in a pod
+                  endpoint: "http://localhost:8080/katalog/loader"
                   cacheFor: 10s
           do:
             workers: 8
@@ -90,6 +56,10 @@ spec:
               value: "{{ .metrics.autoscaleActive }}"
             - path: workers
               value: "{{ .metrics.workers }}"
+            - path: loaderPhase
+              value: "{{ .cross.loader.status.phase }}"
+            - path: loaderDeploymentReady
+              value: "{{ .cross.loader.children.deployment.ready }}"
 
         onCreate:
           deployments:
diff --git a/examples/advanced/12-autoscale/04-sibling-in-cluster/load.sh b/examples/advanced/12-autoscale/04-sibling-in-cluster/load.sh
new file mode 100755
index 00000000..cb9adae8
--- /dev/null
+++ b/examples/advanced/12-autoscale/04-sibling-in-cluster/load.sh
@@ -0,0 +1,122 @@
+#!/usr/bin/env bash
+# load.sh — generic CR loader for autoscale testing.
+#
+# Usage:
+#   ./load.sh <crd> <count>
+#   ./load.sh <crd> up <count>
+#   ./load.sh <crd> down <to>
+#
+# Defaults:
+#   CRD = ingestor
+#
+# Examples:
+#   ./load.sh processor 200
+#   ./load.sh loader up 150
+#   ./load.sh auditor down 10
+#   ./load.sh 100              # defaults to ingestor
+#   ./load.sh down 0           # defaults to ingestor
+
+set -euo pipefail
+
+DEFAULT_CRD="ingestor"
+
+CRD="${1:-$DEFAULT_CRD}"
+CMD="${2:-up}"
+ARG="${3:-}"
+
+# Shorthand: ./load.sh 200
+if [[ "$CRD" =~ ^[0-9]+$ ]]; then
+  ARG="$CRD"
+  CRD="$DEFAULT_CRD"
+  CMD="up"
+fi
+
+# Shorthand: ./load.sh processor 200
+if [[ "$CMD" =~ ^[0-9]+$ ]]; then
+  ARG="$CMD"
+  CMD="up"
+fi
+
+# Valid CRDs
+VALID_CRDS=("ingestor" "loader" "processor" "auditor")
+
+is_valid_crd() {
+  local x
+  for x in "${VALID_CRDS[@]}"; do
+    [[ "$x" == "$1" ]] && return 0
+  done
+  return 1
+}
+
+print_help() {
+  echo "Usage:"
+  echo "  $0 <crd> <count>"
+  echo "  $0 <crd> up <count>"
+  echo "  $0 <crd> down <to>"
+  echo
+  echo "Valid CRDs: ${VALID_CRDS[*]}"
+  echo "(crd defaults to '${DEFAULT_CRD}')"
+}
+
+# Validate CRD
+if ! is_valid_crd "$CRD"; then
+  echo "❌ Unknown CRD '$CRD'"
+  print_help
+  exit 1
+fi
+
+# Validate command
+if [[ "$CMD" != "up" && "$CMD" != "down" ]]; then
+  echo "❌ Unknown command '$CMD'"
+  print_help
+  exit 1
+fi
+
+# Emit correct spec for each CRD
+emit_spec() {
+  case "$1" in
+    loader|processor|ingestor)
+      cat <<EOF
+spec:
+  image: nginx
+  replicas: 1
+EOF
+      ;;
+    auditor)
+      cat <<EOF
+spec:
+  auditMode: "standard"
+EOF
+      ;;
+  esac
+}
+
+case "$CMD" in
+up)
+  COUNT="${ARG:-200}"
+  echo "→ Creating ${CRD}-1 through ${CRD}-${COUNT}"
+  for i in $(seq 1 "$COUNT"); do
+    kubectl apply -f - <<EOF
+apiVersion: autoscale.orkestra.io/v1alpha1
+kind: ${CRD^}
+metadata:
+  name: ${CRD}-$i
+  labels:
+    orkestra.load: "true"
+$(emit_spec "$CRD")
+EOF
+  done
+  echo "✔ Created ${COUNT} ${CRD^} resources"
+  ;;
+
+down)
+  TO="${ARG:-0}"
+  MAX="${4:-500}"
+  echo "→ Deleting ${CRD}-$((TO+1)) through ${CRD}-${MAX}"
+  for i in $(seq 1 "$MAX"); do
+    kubectl delete "$CRD" "${CRD}-$i" --ignore-not-found --wait=false || true
+  done
+  wait
+  echo "✔ Scaled down to ${TO} ${CRD^} resources"
+  ;;
+esac
diff --git a/examples/advanced/12-autoscale/04-external-friend/katalog.yaml b/examples/advanced/12-autoscale/05-external-friend/katalog.yaml
similarity index 97%
rename from examples/advanced/12-autoscale/04-external-friend/katalog.yaml
rename to examples/advanced/12-autoscale/05-external-friend/katalog.yaml
index 6f991a66..86248d87 100644
--- a/examples/advanced/12-autoscale/04-external-friend/katalog.yaml
+++ b/examples/advanced/12-autoscale/05-external-friend/katalog.yaml
@@ -59,7 +59,7 @@ spec:
     # ── Worker (cluster-b) ────────────────────────────────────────────────────
     # Autoscales based on Feeder's queue depth in cluster-a.
     # source.endpoint crosses the cluster boundary — responses are cached
-    # for 20 s to tolerate transient network latency.
+    # for 20s to tolerate transient network latency.
     worker:
       apiTypes:
         group: autoscale.orkestra.io
@@ -79,7 +79,7 @@ spec:
               - field: cross.feeder.metrics.queueDepth
                 greaterThan: "200"
                 source:
-                  endpoint: "http://$FEEDER_ORKESTRA_URL/katalog/feeder/metrics"
+                  endpoint: "http://$FEEDER_ORKESTRA_URL/katalog/feeder"
                   cacheFor: 20s
           do:
             workers: 10
diff --git a/pkg/autoscaler/autoscale_metrics.go b/pkg/autoscaler/autoscale_metrics.go
index 949fed11..31698503 100644
--- a/pkg/autoscaler/autoscale_metrics.go
+++ b/pkg/autoscaler/autoscale_metrics.go
@@ -182,6 +182,7 @@ func IsMetricField(field string) bool {
 func (m *AutoMetrics) AsMap() map[string]interface{} {
 	return map[string]interface{}{
 		"queueDepth":             m.queueDepth.Load(),
+		"workers":                m.workerSem.Capacity(),
 		"workersBusyPercent":     m.workerSem.BusyPercent(),
 		"workersIdlePercent":     m.workerSem.IdlePercent(),
 		"reconcileDurationP95Ms": m.p95.p95Milliseconds(),
diff --git a/pkg/informer/docs/02-namespace-filter.md b/pkg/informer/docs/02-namespace-filter.md
index 79562c23..c5b91efc 100644
--- a/pkg/informer/docs/02-namespace-filter.md
+++ b/pkg/informer/docs/02-namespace-filter.md
@@ -27,7 +27,7 @@ informer cache (in-memory)
         ▼
 per-CRD work queue
         │
-        │  ← Tier 3: reconciler CheckNamespace (existing, unchanged)
+        │  ← Tier 3: reconciler CheckNamespace
         │        Safety net for race conditions during startup,
         │        before the filter map is fully populated.
         │        Defense in depth — not the primary gate.
diff --git a/pkg/kordinator/crd_health_handers.go b/pkg/kordinator/crd_health_handers.go
index 9a668af4..28910a4d 100644
--- a/pkg/kordinator/crd_health_handers.go
+++ b/pkg/kordinator/crd_health_handers.go
@@ -298,12 +298,10 @@ func BuildCRDInfoHandler(
 		// Generate RBAC info for this CRD
 		rbacInfo := generateRBACInfo(crd, v)
 
-		autoMetrics := make(map[string]interface{})
-		if crd.AutoscaleEnabled() {
-			autoMetrics = h.GetAutoMetrics()
-		} else {
-			autoMetrics = nil
-		}
+		// Always expose live metrics so any CRD can be observed via cross.*.metrics.*
+		// by a sibling in a different binary — the observed CRD does not need to
+		// declare autoscale: itself. AutoMetrics is initialised for every reconciler.
+		autoMetrics := h.GetAutoMetrics()
 
 		// When autoscaler is enabled, use WorkerInfo as the authoritative source
 		// for all worker and queue fields — the legacy health counters only track
diff --git a/pkg/orkestra-registry/template/resolver_data.go b/pkg/orkestra-registry/template/resolver_data.go
index 2eabdd13..ff8e38db 100644
--- a/pkg/orkestra-registry/template/resolver_data.go
+++ b/pkg/orkestra-registry/template/resolver_data.go
@@ -13,7 +13,8 @@
 //  3. resolver.WithItem(val, as)    — adds .item / .<as> for forEach loops
 //  4. resolver.WithExternal(map)    — adds .external.<name>.status / .body
 //  5. resolver.WithCross(map)       — adds .cross.<kind>.status.*
-//  6. resolver.WithPrevious(map)    — adds .previous.* (rollback path only)
+//  6. resolver.WithMetrics(map)     — adds .metrics.queueDepth / .workers / .autoscaleActive …
+//  7. resolver.WithPrevious(map)    — adds .previous.* (rollback path only)
 //
 // Each extension is a shallow copy of the previous resolver's data map
 // with one new top-level key added. The template engine sees the full
@@ -34,6 +35,8 @@ package template
 //	.children.*  — child resources, after WithChildren is called
 //	.external.*  — HTTP call results, after WithExternal is called
 //	.cross.*     — cross-CRD observations, after WithCross is called
+//	.metrics.*   — live operatorbox runtime metrics, after WithMetrics is called
+//	.health.*   — live operatorbox runtime health metrics, after WithHealth is called
 //	.item        — current forEach item, after WithItem is called
 //	.previous.*  — last successfully reconciled spec, after WithPrevious is called (rollback path only)
 //
@@ -318,6 +321,71 @@ func (r *Resolver) WithPrevious(previous map[string]interface{}) *Resolver {
 	}
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// WithMetrics — live operatorbox runtime metrics injection
+// ─────────────────────────────────────────────────────────────────────────────
+
+// WithMetrics returns a new Resolver with live operatorbox runtime metrics
+// injected under the "metrics" key. Makes the following available in templates:
+//
+//	{{ .metrics.queueDepth }}             — current workqueue depth
+//	{{ .metrics.workers }}                — current effective worker count
+//	{{ .metrics.autoscaleActive }}        — "true"/"false" — override active
+//	{{ .metrics.workersBusyPercent }}     — worker utilisation %
+//	{{ .metrics.workersIdlePercent }}     — idle worker %
+//	{{ .metrics.errorRatePercent }}       — reconcile error rate %
+//	{{ .metrics.reconcileDurationP95Ms }} — P95 reconcile latency (ms)
+//
+// Useful in status.fields to surface live runtime state into CR status.
+func (r *Resolver) WithMetrics(metrics map[string]interface{}) *Resolver {
+	if len(metrics) == 0 {
+		return r
+	}
+	newData := r.shallowCopy()
+	newData["metrics"] = metrics
+	return &Resolver{
+		data:           newData,
+		ownerName:      r.ownerName,
+		ownerNamespace: r.ownerNamespace,
+	}
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// WithHealth — live operatorbox runtime health injection
+// ─────────────────────────────────────────────────────────────────────────────
+
+// WithHealth returns a new Resolver with live operatorbox runtime health
+// injected under the "health" key. Makes the following available in templates:
+//
+//   {{ .health.healthy }}                 — boolean: overall health
+//   {{ .health.state }}                   — "healthy" / "degraded" / "error"
+//   {{ .health.started }}                 — runtime started flag
+//   {{ .health.pending }}                 — pending startup
+//   {{ .health.startedAt }}               — RFC3339 timestamp
+//   {{ .health.uptime }}                  — human‑readable uptime
+//   {{ .health.queueDepth }}              — current queue depth
+//   {{ .health.errorRate }}               — reconcile error rate
+//   {{ .health.consecutiveFails }}        — consecutive reconcile failures
+//   {{ .health.totalReconciles }}         — total reconciles since start
+//   {{ .health.resourceCount }}           — number of managed CRs
+//   {{ .health.lastError }}               — last reconcile error (string)
+//   {{ .health.lastReconcile }}           — timestamp of last reconcile
+//   {{ .health.hasUnhealthyDependencies }}— dependency health flag
+//
+// Useful in status.fields to surface live runtime health into CR status.
+func (r *Resolver) WithHealth(health map[string]interface{}) *Resolver {
+    if len(health) == 0 {
+        return r
+    }
+    newData := r.shallowCopy()
+    newData["health"] = health
+    return &Resolver{
+        data:           newData,
+        ownerName:      r.ownerName,
+        ownerNamespace: r.ownerNamespace,
+    }
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // shallowCopy — internal helper
 // ─────────────────────────────────────────────────────────────────────────────
diff --git a/pkg/reconciler/generic.go b/pkg/reconciler/generic.go
index 0e23cc89..d2f07e02 100644
--- a/pkg/reconciler/generic.go
+++ b/pkg/reconciler/generic.go
@@ -484,11 +484,22 @@ func (r *GenericReconciler[PTR]) reconcileImpl(ctx context.Context, resolver *or
 		r.clearFailureHistory(obj.GetNamespace() + "/" + obj.GetName())
 	}
 
+	// Inject live runtime metrics into the resolver so status.fields templates
+	// can reference .metrics.queueDepth, .metrics.workers, .metrics.autoscaleActive, etc.
+	metricsMap := r.autoMetrics.AsMap()
+	if r.autoscaler != nil {
+		if snap := r.autoscaler.Snapshot(); snap != nil {
+			metricsMap["autoscaleActive"] = snap.OverrideActive
+		}
+	} else {
+		metricsMap["autoscaleActive"] = false
+	}
+	resolver = resolver.WithMetrics(metricsMap)
+
 	// Always patch status — best-effort, never fails reconcile.
 	// Called with the outcome so Ready condition reflects reality.
 	// Must run before the error return so Ready=False is written on failure.
-	// r.updatedPatchStatus(ctx, obj, err)
-	r.patchStatusWithChildren(ctx, obj, resolver, err) // Layer 3: read children only on success — no point reading
+	r.patchStatusWithChildren(ctx, obj, resolver, err)
 
 	if err != nil {
 		logger.FromContext(ctx).Error().Err(err).
diff --git a/pkg/reconciler/ptr_hooks.go b/pkg/reconciler/ptr_hooks.go
index 5d5c84f5..ed91db78 100644
--- a/pkg/reconciler/ptr_hooks.go
+++ b/pkg/reconciler/ptr_hooks.go
@@ -7,7 +7,7 @@
 // GenericReconciler uses the type parameter name PTR rather than the
 // conventional T to make the pointer expectation visible at every call site.
 // Kubernetes informers store and return pointer values: when you create an
-// informer for Database objects, every item retrieved from its cache is a
+// informer for Database objects for example, every item retrieved from its cache is a
 // *Database. The reconciler type-asserts the raw interface{} value from the
 // cache with raw.(PTR), which succeeds only when PTR is a pointer type.
 //
diff --git a/pkg/reconciler/run_foreach.go b/pkg/reconciler/run_foreach.go
index 7309ecca..2689b272 100644
--- a/pkg/reconciler/run_foreach.go
+++ b/pkg/reconciler/run_foreach.go
@@ -781,6 +781,56 @@ func expandForEachPVs(
 	return result
 }
 
+func expandForEachRoles(
+	resolver *orktmpl.Resolver,
+	srcs []orktypes.RoleTemplateSource,
+) []orktypes.RoleTemplateSource {
+	if !anyHasForEach(len(srcs), func(i int) *orktypes.ForEachSpec { return srcs[i].ForEach }) {
+		return srcs
+	}
+	var result []orktypes.RoleTemplateSource
+	for _, src := range srcs {
+		if src.ForEach == nil {
+			result = append(result, src)
+			continue
+		}
+		for i, fi := range resolveForEachItems(resolver.Data(), src.ForEach.Field) {
+			ir := itemResolver(resolver, fi, src.ForEach.As, i)
+			expanded := src
+			expanded.ForEach = nil
+			expanded.Name, _ = ir.Resolve(src.Name)
+			expanded.Namespace, _ = ir.Resolve(src.Namespace)
+			result = append(result, expanded)
+		}
+	}
+	return result
+}
+
+func expandForEachRoleBindings(
+	resolver *orktmpl.Resolver,
+	srcs []orktypes.RoleBindingTemplateSource,
+) []orktypes.RoleBindingTemplateSource {
+	if !anyHasForEach(len(srcs), func(i int) *orktypes.ForEachSpec { return srcs[i].ForEach }) {
+		return srcs
+	}
+	var result []orktypes.RoleBindingTemplateSource
+	for _, src := range srcs {
+		if src.ForEach == nil {
+			result = append(result, src)
+			continue
+		}
+		for i, fi := range resolveForEachItems(resolver.Data(), src.ForEach.Field) {
+			ir := itemResolver(resolver, fi, src.ForEach.As, i)
+			expanded := src
+			expanded.ForEach = nil
+			expanded.Name, _ = ir.Resolve(src.Name)
+			expanded.Namespace, _ = ir.Resolve(src.Namespace)
+			result = append(result, expanded)
+		}
+	}
+	return result
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Internal helpers
 // ─────────────────────────────────────────────────────────────────────────────
@@ -854,66 +904,6 @@ func itemResolver(base *orktmpl.Resolver, fi forEachItem, as string, index int)
 	return base.WithItem(fi.key, as, index)
 }
 
-// resolveListField is kept for backward compatibility with any callers outside this file.
-func resolveListField(data map[string]interface{}, path string) []interface{} {
-	items := resolveForEachItems(data, path)
-	result := make([]interface{}, len(items))
-	for i, fi := range items {
-		result[i] = fi.key
-	}
-	return result
-}
-
-func expandForEachRoles(
-	resolver *orktmpl.Resolver,
-	srcs []orktypes.RoleTemplateSource,
-) []orktypes.RoleTemplateSource {
-	if !anyHasForEach(len(srcs), func(i int) *orktypes.ForEachSpec { return srcs[i].ForEach }) {
-		return srcs
-	}
-	var result []orktypes.RoleTemplateSource
-	for _, src := range srcs {
-		if src.ForEach == nil {
-			result = append(result, src)
-			continue
-		}
-		for i, fi := range resolveForEachItems(resolver.Data(), src.ForEach.Field) {
-			ir := itemResolver(resolver, fi, src.ForEach.As, i)
-			expanded := src
-			expanded.ForEach = nil
-			expanded.Name, _ = ir.Resolve(src.Name)
-			expanded.Namespace, _ = ir.Resolve(src.Namespace)
-			result = append(result, expanded)
-		}
-	}
-	return result
-}
-
-func expandForEachRoleBindings(
-	resolver *orktmpl.Resolver,
-	srcs []orktypes.RoleBindingTemplateSource,
-) []orktypes.RoleBindingTemplateSource {
-	if !anyHasForEach(len(srcs), func(i int) *orktypes.ForEachSpec { return srcs[i].ForEach }) {
-		return srcs
-	}
-	var result []orktypes.RoleBindingTemplateSource
-	for _, src := range srcs {
-		if src.ForEach == nil {
-			result = append(result, src)
-			continue
-		}
-		for i, fi := range resolveForEachItems(resolver.Data(), src.ForEach.Field) {
-			ir := itemResolver(resolver, fi, src.ForEach.As, i)
-			expanded := src
-			expanded.ForEach = nil
-			expanded.Name, _ = ir.Resolve(src.Name)
-			expanded.Namespace, _ = ir.Resolve(src.Namespace)
-			result = append(result, expanded)
-		}
-	}
-	return result
-}
-
 // splitFieldPath splits a dot-notation path into segments.
 func splitFieldPath(path string) []string {
 	var parts []string
diff --git a/pkg/reconciler/run_template_reconcile.go b/pkg/reconciler/run_template_reconcile.go
index fedcf167..323b5f27 100644
--- a/pkg/reconciler/run_template_reconcile.go
+++ b/pkg/reconciler/run_template_reconcile.go
@@ -309,7 +309,9 @@ func (r *GenericReconciler[PTR]) readCross(
 					Msg("cross: no CRD matched label selector in registry")
 			}
 		}
-		// Path 1b: name-based informer lookup (existing, unchanged)
+
+		notFoundInBianry := false
+		// Path 1b: name-based informer lookup
 		if decl.Crd != "" && r.katalogRegistry != nil {
 			inf, found := r.katalogRegistry.GetInformerByName(decl.Crd)
 			if found {
@@ -322,13 +324,10 @@ func (r *GenericReconciler[PTR]) readCross(
 				result[as] = data
 				continue
 			}
-			log.Warn().
-				Str("crd", decl.Crd).
-				Str("as", as).
-				Bool("registry_nil", registryNil).
-				Msg("cross: no CRD matched name in registry")
+			notFoundInBianry = true
 		}
 
+		notFoundCrossBinary := false
 		// Path 2: HTTP endpoint fallback.
 		// For cross-binary or cross-cluster. Uses Orkestra's CR detail endpoint.
 		if decl.Source != nil && decl.Source.Endpoint != "" {
@@ -344,12 +343,21 @@ func (r *GenericReconciler[PTR]) readCross(
 					Msg("cross: read via HTTP endpoint")
 				continue
 			}
+			notFoundCrossBinary = true
 			log.Warn().
 				Str("crd", decl.Crd).
 				Str("endpoint", endpointURL).
 				Msg("cross: HTTP endpoint returned nil")
 		}
 
+		if notFoundInBianry && notFoundCrossBinary {
+			log.Warn().
+				Str("crd", decl.Crd).
+				Str("as", as).
+				Bool("registry_nil", registryNil).
+				Msg("cross: no CRD matched name in registry")
+		}
+
 		// Path 3: not found.
 		result[as] = map[string]interface{}{
 			"found":     "false",

From eadddef95679cfae65a9b7781e06a0f44aa85347 Mon Sep 17 00:00:00 2001
From: ialexeze <ialexeze@gmail.com>
Date: Wed, 13 May 2026 13:56:58 +0000
Subject: [PATCH 3/3] cross-health works

---
 cmd/internal/konstructor.go                   | 23 ++---
 .../katalog-processor.yaml                    | 30 ++++++-
 pkg/kordinator/crd_health.go                  | 83 +++++++++++++++++++
 pkg/kordinator/crd_health_handers.go          | 36 ++------
 .../template/resolver_data.go                 | 58 ++++++-------
 pkg/reconciler/generic.go                     | 52 +++++++-----
 pkg/reconciler/generic_registry.go            |  6 ++
 pkg/types/conditions.go                       |  8 +-
 pkg/types/cross.go                            | 43 +++++++---
 9 files changed, 238 insertions(+), 101 deletions(-)

diff --git a/cmd/internal/konstructor.go b/cmd/internal/konstructor.go
index 3dbfbc79..018644e3 100644
--- a/cmd/internal/konstructor.go
+++ b/cmd/internal/konstructor.go
@@ -288,6 +288,16 @@ func konstructOrkestra(kfg *konfig.Konfig, m *merger.Merger, ctx context.Context
 	// enabling cross-CRD observation with zero API server calls.
 	ktrlRegistry := kordinator.NewKordinatorRegistry()
 
+	// ── 4e. CRD health map ────────────────────────────────────────────────────
+	// One CRDHealth per CRD — shared between the DependencyKordinator
+	// (which updates it on each reconcile) and the HTTP health routes
+	// (which read it on each request). All three reference the same pointers.
+	crdHealthMap := make(map[string]*kordinator.CRDHealth)
+	for _, crd := range kat.Enabled() {
+		gvk := crd.GVK().String()
+		crdHealthMap[gvk] = kordinator.NewCRDHealth(crd.Name)
+	}
+
 	logger.Debug().Msg("wiring CRDs into kordinator registry...")
 
 	finalizers := kfg.Finalizers()
@@ -408,6 +418,7 @@ func konstructOrkestra(kfg *konfig.Konfig, m *merger.Merger, ctx context.Context
 						return objCopy.DeepCopyObject().(domain.Object)
 					},
 					ktrlRegistry,     // cross-CRD informer lookup via GetInformerByName
+					crdHealthMap,     // cross-CRD health map via HealthProvider
 					providerRegistry, // aws:, mongodb:, etc. block dispatch
 					pStats,           // per-CRD provider error rate tracking
 				)
@@ -432,17 +443,7 @@ func konstructOrkestra(kfg *konfig.Konfig, m *merger.Merger, ctx context.Context
 		logger.Debug().Str("gvk", gvk).Msg("CRD registered")
 	}
 
-	// ── 5a. CRD health map ────────────────────────────────────────────────────
-	// One CRDHealth per CRD — shared between the DependencyKordinator
-	// (which updates it on each reconcile) and the HTTP health routes
-	// (which read it on each request). All three reference the same pointers.
-	crdHealthMap := make(map[string]*kordinator.CRDHealth)
-	for _, crd := range kat.Enabled() {
-		gvk := crd.GVK().String()
-		crdHealthMap[gvk] = kordinator.NewCRDHealth(crd.Name)
-	}
-
-	// ── 5b. HTTP routes ───────────────────────────────────────────────────────
+	// ── 5. HTTP routes ───────────────────────────────────────────────────────
 	// All routes registered before hs.Start() — the mux is shared.
 	//
 	// Per-CRD routes:
diff --git a/examples/advanced/12-autoscale/04-sibling-in-cluster/katalog-processor.yaml b/examples/advanced/12-autoscale/04-sibling-in-cluster/katalog-processor.yaml
index cd935f0c..a310f8be 100644
--- a/examples/advanced/12-autoscale/04-sibling-in-cluster/katalog-processor.yaml
+++ b/examples/advanced/12-autoscale/04-sibling-in-cluster/katalog-processor.yaml
@@ -32,6 +32,20 @@ spec:
       resync: 30s
 
       operatorBox:
+        cross:
+          # Monitors a particular Loader CR called 'my-loader'
+          - crd: loader
+            selector:
+              name: my-loader
+            source:
+              endpoint: "http://localhost:8080/katalog/loader/cr/default/my-loader"
+            as: loaderInfo
+
+          # Monitor the operator itself
+          - crd: loader
+            source:
+              endpoint: "http://localhost:8080/katalog/loader/health"
+            as: loaderHealth
         autoscale:
           interval: 20s
           cooldown: 3m
@@ -56,10 +70,22 @@ spec:
               value: "{{ .metrics.autoscaleActive }}"
             - path: workers
               value: "{{ .metrics.workers }}"
+            - path: lastError
+              value: "{{ .health.lastError }}"
+            - path: state
+              value: "{{ .health.state }}"
+            - path: loaderQueueDepth
+              value: "{{ .cross.loaderInfo.metrics.queueDepth }}"
+            - path: loaderState
+              value: "{{ .cross.loaderInfo.status.phase }}"
+            - path: loaderHealthy
+              value: "{{ .cross.loaderHealth.healthy }}"
+            - path: loaderLastError
+              value: "{{ .cross.loaderHealth.lastError }}"
             - path: loaderPhase
-              value: "{{ .cross.loader.status.phase }}"
+              value: "{{ .cross.loaderHealth.state }}"
             - path: loaderDeploymentReady
-              value: "{{ .cross.loader.children.deployment.ready }}"
+              value: "{{ .cross.loaderInfo.children.deployment.ready }}"
 
         onCreate:
           deployments:
diff --git a/pkg/kordinator/crd_health.go b/pkg/kordinator/crd_health.go
index b748de1d..5a2cc0eb 100644
--- a/pkg/kordinator/crd_health.go
+++ b/pkg/kordinator/crd_health.go
@@ -2,6 +2,7 @@
 package kordinator
 
 import (
+	"net/http"
 	"sync"
 	"sync/atomic"
 	"time"
@@ -530,3 +531,85 @@ func (h *CRDHealth) GetDependencyStatuses() map[string]DependencyStatus {
 	}
 	return result
 }
+
+// StateAndStatus returns the reconciler's derived health state and the
+// corresponding HTTP status code used by the /health endpoint.
+//
+// State is one of:
+//
+//	"not started", "pending", "degraded", "healthy"
+//
+// Status is either:
+//
+//	200 — healthy or pending
+//	503 — degraded or not started
+func (h *CRDHealth) StateAndStatus() (string, int) {
+	if h == nil {
+		return "not started", http.StatusServiceUnavailable
+	}
+
+	isStarted := h.Started()
+	isPending := h.Pending()
+	isHealthy := h.IsHealthy()
+
+	switch {
+	case !isStarted && !isPending:
+		return "not started", http.StatusServiceUnavailable
+	case isPending:
+		return "pending", http.StatusOK
+	case isStarted && !isHealthy:
+		return "degraded", http.StatusServiceUnavailable
+	case isHealthy:
+		return "healthy", http.StatusOK
+	default:
+		return "pending", http.StatusOK
+	}
+}
+
+// HealthAsMap returns a snapshot of this CRD's health as a plain map, suitable
+// for injection into the template resolver under the "health" key.
+//
+// Available in conditions status.fields templates as:
+//
+//		{{ .health.healthy }}            — bool: reconciler is healthy
+//	 {{ .health.state }}              — string: "healthy" / "degraded" / "pending" / "not started"
+//	 {{ .health.status }}             — int: HTTP status code representing health state
+//		{{ .health.started }}            — bool: reconciler has started
+//		{{ .health.pending }}            — bool: reconciler is pending
+//		{{ .health.degraded }}           — bool: reconciler is degraded
+//		{{ .health.totalReconciles }}    — int64: total reconcile attempts
+//		{{ .health.failedReconciles }}   — int64: total failed reconciles
+//		{{ .health.consecutiveFails }}   — int64: current consecutive failure streak
+//		{{ .health.errorRatePercent }}   — float64: error rate as percentage
+//		{{ .health.lastReconcile }}      — string: RFC3339 timestamp of last reconcile
+//		{{ .health.uptime }}             — string: how long the reconciler has been running
+//		{{ .health.lastError }}          — string: most recent error message (empty if none)
+//		{{ .health.rollbackActive }}     — bool: rollback is currently blocking reconcile
+//		{{ .health.rollbackTotal }}      — int64: total rollback triggers since startup
+//		{{ .health.hasUnhealthyDeps }}   — bool: any dependency is unsatisfied
+func (h *CRDHealth) HealthAsMap() map[string]interface{} {
+	if h == nil {
+		return map[string]interface{}{}
+	}
+
+	state, status := h.StateAndStatus()
+
+	return map[string]interface{}{
+		"healthy":          h.IsHealthy(),
+		"state":            state,
+		"status":           status,
+		"started":          h.started.Load(),
+		"pending":          h.pending.Load(),
+		"degraded":         h.degraded.Load(),
+		"totalReconciles":  h.totalReconciles.Load(),
+		"failedReconciles": h.failedReconciles.Load(),
+		"consecutiveFails": h.consecutiveFails.Load(),
+		"errorRatePercent": h.ErrorRatePercent(),
+		"lastReconcile":    h.LastReconcile(),
+		"uptime":           h.Uptime(),
+		"lastError":        h.LastError(),
+		"rollbackActive":   h.rollbackActive.Load(),
+		"rollbackTotal":    h.rollbackTotal.Load(),
+		"hasUnhealthyDeps": h.hasUnhealthyDeps.Load(),
+	}
+}
diff --git a/pkg/kordinator/crd_health_handers.go b/pkg/kordinator/crd_health_handers.go
index 28910a4d..e85951c4 100644
--- a/pkg/kordinator/crd_health_handers.go
+++ b/pkg/kordinator/crd_health_handers.go
@@ -23,6 +23,7 @@ import (
 type CRDHealthResponse struct {
 	Name                     string                      `json:"name"`
 	State                    string                      `json:"state"` // "not started", "pending", "started", "healthy", "degraded"
+	Status                   int                         `json:"status"`
 	Healthy                  bool                        `json:"healthy"`
 	Started                  bool                        `json:"started"`
 	Pending                  bool                        `json:"pending"`
@@ -65,39 +66,16 @@ func BuildCRDHealthHandler(
 	h *CRDHealth,
 ) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		isStarted := h.Started()
-		isPending := h.Pending()
-		isHealthy := h.IsHealthy()
-
-		var httpStatus int
-		var state string
-
-		switch {
-		case !isStarted && !isPending:
-			httpStatus = http.StatusServiceUnavailable
-			state = "not started"
-		case isPending:
-			httpStatus = http.StatusOK
-			state = "pending"
-		case isStarted && !isHealthy:
-			httpStatus = http.StatusServiceUnavailable
-			state = "degraded"
-		case isHealthy:
-			httpStatus = http.StatusOK
-			state = "healthy"
-		default:
-			httpStatus = http.StatusOK
-			state = "pending"
-		}
-
+		state, status := h.StateAndStatus()
 		v := resolveCRDDisplayValues(crd, kfg, inf)
 
 		response := CRDHealthResponse{
 			Name:                     crd.Name,
 			State:                    state,
-			Healthy:                  isHealthy,
-			Started:                  isStarted,
-			Pending:                  isPending,
+			Status:                   status,
+			Healthy:                  h.IsHealthy(),
+			Started:                  h.Started(),
+			Pending:                  h.Pending(),
 			StartedAt:                h.StartedAt(),
 			Uptime:                   h.Uptime(),
 			QueueDepth:               h.QueueDepth(crd.GVK().String()),
@@ -112,7 +90,7 @@ func BuildCRDHealthHandler(
 			Missing:                  h.IsMissing(),
 		}
 
-		utils.WriteJSON(w, httpStatus, response)
+		utils.WriteJSON(w, status, response)
 	}
 }
 
diff --git a/pkg/orkestra-registry/template/resolver_data.go b/pkg/orkestra-registry/template/resolver_data.go
index ff8e38db..4b5db395 100644
--- a/pkg/orkestra-registry/template/resolver_data.go
+++ b/pkg/orkestra-registry/template/resolver_data.go
@@ -130,19 +130,19 @@ func (r *Resolver) WithItemAndValue(key interface{}, value interface{}, as strin
 // Each call result is keyed by the call's name from the Katalog:
 //
 //	external:
-//	  - name: health-check
+//	  - name: healthCheck
 //	    url: "{{ .spec.serviceUrl }}/health"
 //
 // Results accessible in subsequent template expressions and when: conditions:
 //
-//	{{ .external.health-check.status }}    → HTTP status code as string
-//	{{ .external.health-check.body }}      → response body (first 4KB)
-//	{{ .external.health-check.error }}     → error message if call failed
+//	{{ .external.healthCheck.status }}    → HTTP status code as string
+//	{{ .external.healthCheck.body }}      → response body (first 4KB)
+//	{{ .external.healthCheck.error }}     → error message if call failed
 //
 // Resource declarations that follow in runTemplateReconcile can gate on these:
 //
 //	when:
-//	  - field: external.health-check.status
+//	  - field: external.healthCheck.status
 //	    equals: "200"
 func (r *Resolver) WithExternal(results map[string]interface{}) *Resolver {
 	if len(results) == 0 {
@@ -357,33 +357,33 @@ func (r *Resolver) WithMetrics(metrics map[string]interface{}) *Resolver {
 // WithHealth returns a new Resolver with live operatorbox runtime health
 // injected under the "health" key. Makes the following available in templates:
 //
-//   {{ .health.healthy }}                 — boolean: overall health
-//   {{ .health.state }}                   — "healthy" / "degraded" / "error"
-//   {{ .health.started }}                 — runtime started flag
-//   {{ .health.pending }}                 — pending startup
-//   {{ .health.startedAt }}               — RFC3339 timestamp
-//   {{ .health.uptime }}                  — human‑readable uptime
-//   {{ .health.queueDepth }}              — current queue depth
-//   {{ .health.errorRate }}               — reconcile error rate
-//   {{ .health.consecutiveFails }}        — consecutive reconcile failures
-//   {{ .health.totalReconciles }}         — total reconciles since start
-//   {{ .health.resourceCount }}           — number of managed CRs
-//   {{ .health.lastError }}               — last reconcile error (string)
-//   {{ .health.lastReconcile }}           — timestamp of last reconcile
-//   {{ .health.hasUnhealthyDependencies }}— dependency health flag
+//	{{ .health.healthy }}                 — boolean: overall health
+//	{{ .health.state }}                   — "healthy" / "degraded" / "error"
+//	{{ .health.started }}                 — runtime started flag
+//	{{ .health.pending }}                 — pending startup
+//	{{ .health.startedAt }}               — RFC3339 timestamp
+//	{{ .health.uptime }}                  — human‑readable uptime
+//	{{ .health.queueDepth }}              — current queue depth
+//	{{ .health.errorRate }}               — reconcile error rate
+//	{{ .health.consecutiveFails }}        — consecutive reconcile failures
+//	{{ .health.totalReconciles }}         — total reconciles since start
+//	{{ .health.resourceCount }}           — number of managed CRs
+//	{{ .health.lastError }}               — last reconcile error (string)
+//	{{ .health.lastReconcile }}           — timestamp of last reconcile
+//	{{ .health.hasUnhealthyDependencies }}— dependency health flag
 //
 // Useful in status.fields to surface live runtime health into CR status.
 func (r *Resolver) WithHealth(health map[string]interface{}) *Resolver {
-    if len(health) == 0 {
-        return r
-    }
-    newData := r.shallowCopy()
-    newData["health"] = health
-    return &Resolver{
-        data:           newData,
-        ownerName:      r.ownerName,
-        ownerNamespace: r.ownerNamespace,
-    }
+	if len(health) == 0 {
+		return r
+	}
+	newData := r.shallowCopy()
+	newData["health"] = health
+	return &Resolver{
+		data:           newData,
+		ownerName:      r.ownerName,
+		ownerNamespace: r.ownerNamespace,
+	}
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
diff --git a/pkg/reconciler/generic.go b/pkg/reconciler/generic.go
index d2f07e02..71c0e43e 100644
--- a/pkg/reconciler/generic.go
+++ b/pkg/reconciler/generic.go
@@ -61,12 +61,13 @@ import (
 // because the informer cache always holds the correct underlying concrete type.
 // See pkg/reconciler/ptr_hooks.go for the full design rationale.
 type GenericReconciler[PTR domain.Object] struct {
-	katalogRegistry  *kordinator.ResourceKatalog
-	providerRegistry orktypes.ProviderRegistry
-	providerStats    providerStatsRecorder
-	informer         cache.SharedIndexInformer
-	event            *event.Event
-	kube             *kubeclient.Kubeclient
+	katalogRegistry   *kordinator.ResourceKatalog
+	crdHealthRegistry map[string]*kordinator.CRDHealth
+	providerRegistry  orktypes.ProviderRegistry
+	providerStats     providerStatsRecorder
+	informer          cache.SharedIndexInformer
+	event             *event.Event
+	kube              *kubeclient.Kubeclient
 	// hooks holds type-erased, domain.Object-parameterized callbacks built at
 	// construction time from the user's ReconcileHooks[PTR]. Stored as
 	// ObjectHooks rather than ReconcileHooks[PTR] so the reconciler remains
@@ -134,6 +135,7 @@ func NewGenericReconciler[PTR domain.Object](
 	anyHooks domain.AnyReconcileHooks,
 	newObj func() PTR,
 	katalogRegistry *kordinator.ResourceKatalog,
+	crdHealthRegistry map[string]*kordinator.CRDHealth,
 	providerRegistry orktypes.ProviderRegistry,
 	providerStats providerStatsRecorder,
 ) *GenericReconciler[PTR] {
@@ -164,19 +166,20 @@ func NewGenericReconciler[PTR domain.Object](
 	autoMet := autoscaler.NewAutoMetrics(sem)
 
 	r := &GenericReconciler[PTR]{
-		katalogRegistry:  katalogRegistry,
-		providerRegistry: providerRegistry,
-		providerStats:    providerStats,
-		crd:              crd,
-		operatorBox:      crd.OperatorBox,
-		informer:         informer,
-		event:            ev,
-		kube:             kube,
-		hooks:            hooks,
-		newObj:           newObj,
-		workerSem:        sem,
-		autoMetrics:      autoMet,
-		rollbackHistory:  make(map[string]*rollbackFailureHistory),
+		katalogRegistry:   katalogRegistry,
+		crdHealthRegistry: crdHealthRegistry,
+		providerRegistry:  providerRegistry,
+		providerStats:     providerStats,
+		crd:               crd,
+		operatorBox:       crd.OperatorBox,
+		informer:          informer,
+		event:             ev,
+		kube:              kube,
+		hooks:             hooks,
+		newObj:            newObj,
+		workerSem:         sem,
+		autoMetrics:       autoMet,
+		rollbackHistory:   make(map[string]*rollbackFailureHistory),
 	}
 
 	if crd.AutoscaleEnabled() {
@@ -496,6 +499,17 @@ func (r *GenericReconciler[PTR]) reconcileImpl(ctx context.Context, resolver *or
 	}
 	resolver = resolver.WithMetrics(metricsMap)
 
+	// Inject live runtime health into the resolver so status.fields templates
+	// can reference .health.healthy, .health.state, .health.uptime,
+	// .health.totalReconciles, .health.lastError, etc.
+	//
+	// This surfaces the operatorbox health endpoint directly into templates,
+	// enabling CR status fields to show live reconcile health, uptime,
+	// dependency health, and error information without any API calls.
+	if h, ok := r.crdHealthRegistry[r.crd.GVK().String()]; ok {
+		resolver = resolver.WithHealth(h.HealthAsMap())
+	}
+
 	// Always patch status — best-effort, never fails reconcile.
 	// Called with the outcome so Ready condition reflects reality.
 	// Must run before the error return so Ready=False is written on failure.
diff --git a/pkg/reconciler/generic_registry.go b/pkg/reconciler/generic_registry.go
index 938cc4ee..0be96c29 100644
--- a/pkg/reconciler/generic_registry.go
+++ b/pkg/reconciler/generic_registry.go
@@ -31,3 +31,9 @@ type KatalogRegistry interface {
 	// key and value. Returns nil, false when no CRD matches.
 	GetInformerByLabel(key, value string) (cache.SharedIndexInformer, bool)
 }
+
+// HealthProvider is the minimal interface GenericReconciler needs
+// to expose CRD health to templates without importing kordinator.
+type HealthProvider interface {
+	HealthAsMap() map[string]interface{}
+}
diff --git a/pkg/types/conditions.go b/pkg/types/conditions.go
index 48e4667f..7092b085 100644
--- a/pkg/types/conditions.go
+++ b/pkg/types/conditions.go
@@ -106,7 +106,13 @@ type Condition struct {
 	//     - field: cross.managed-database.metrics.queueDepth
 	//       greaterThan: "500"
 	//       source:
-	//         endpoint: "http://database-operator:8080/katalog/managed-database"
+	//         host: "http://orkestra-database-operator:8080"
+	// 		   crd: managed-database
+	//   when:
+	//     - field: cross.managed-database.metrics.queueDepth
+	//       greaterThan: "500"
+	//       source:
+	//         endpoint: "http://non-orkestra-database-operator:8080/katalog/managed-database"
 	Source *CrossSource `yaml:"source,omitempty" json:"source,omitempty"`
 }
 
diff --git a/pkg/types/cross.go b/pkg/types/cross.go
index 74f1022d..3cdfd10b 100644
--- a/pkg/types/cross.go
+++ b/pkg/types/cross.go
@@ -110,19 +110,42 @@ type CrossSelector struct {
 	LabelSelector string `yaml:"labelSelector,omitempty" json:"labelSelector,omitempty"`
 }
 
-// CrossSource declares an HTTP fallback for cross-binary/cluster observation.
+// CrossSource declares how to fetch cross-binary/cluster data for a CRD.
+// If Endpoint is provided, it is used as-is (raw HTTP fetch).
+// If Host is provided, Orkestra constructs the URL based on Type.
+//
+// Supported Type values:
+//   - "info"    → /katalog/<crd>/cr/<ns>/<name>
+//   - "metrics" → /katalog/<crd>
+//   - "health"  → /katalog/<crd>/health
+//   - "events"  → /katalog/<crd>/cr/<ns>/<name>/events
+//
 // The endpoint must return the same JSON shape as the informer cache path —
 // i.e., the Orkestra CR detail endpoint format.
+// Namespace is optional; defaults to the CR's namespace when omitted.
 type CrossSource struct {
-	// Endpoint is the URL to call when the informer is unavailable.
-	// Template expressions supported.
-	//   endpoint: "http://database-operator:8080/katalog/database/cr/{{ .metadata.namespace }}/{{ .metadata.name }}"
-	Endpoint string `yaml:"endpoint" json:"endpoint"`
+    // Endpoint is a fully-qualified URL. If set, Orkestra uses it directly
+    // and ignores Host/Type/Namespace. Template expressions supported.
+    Endpoint string `yaml:"endpoint,omitempty" json:"endpoint,omitempty"`
+
+    // Host is the base URL of a remote Orkestra runtime, e.g.:
+    //   http://orkestra-runtime.loader-system:8080
+    // Combined with Type to build the final URL.
+    Host string `yaml:"host,omitempty" json:"host,omitempty"`
+
+    // Type selects which Orkestra-native endpoint to call.
+    // One of: "info", "metrics", "health", "events".
+    // Default: "info".
+    Type string `yaml:"type,omitempty" json:"type,omitempty"`
+
+    // Namespace overrides the CR namespace when building info/events URLs.
+    // Optional — defaults to the CR's own namespace.
+    Namespace string `yaml:"namespace,omitempty" json:"namespace,omitempty"`
 
-	// Token is a bearer token for the endpoint. $ENV_VAR syntax supported.
-	Token string `yaml:"token,omitempty" json:"token,omitempty"`
+    // Token is a bearer token for the endpoint. $ENV_VAR syntax supported.
+    Token string `yaml:"token,omitempty" json:"token,omitempty"`
 
-	// CacheFor is how long to cache the result before calling again.
-	// Default: 30s — prevents hammering the endpoint on every resync.
-	CacheFor string `yaml:"cacheFor,omitempty" json:"cacheFor,omitempty"`
+    // CacheFor controls how long to cache the result before calling again.
+    // Default: 30s — prevents hammering the endpoint on every evaluation.
+    CacheFor string `yaml:"cacheFor,omitempty" json:"cacheFor,omitempty"`
 }