diff --git a/acceptance/bundle/telemetry/config-remote-sync-error/databricks.yml b/acceptance/bundle/telemetry/config-remote-sync-error/databricks.yml
new file mode 100644
index 00000000000..c0c9f880163
--- /dev/null
+++ b/acceptance/bundle/telemetry/config-remote-sync-error/databricks.yml
@@ -0,0 +1,11 @@
+bundle:
+  name: config-remote-sync-telemetry-error
+
+resources:
+  jobs:
+    foo:
+      name: test job
+      tasks:
+        - task_key: main
+          notebook_task:
+            notebook_path: /Workspace/Users/tester@databricks.com/notebook
diff --git a/acceptance/bundle/telemetry/config-remote-sync-error/out.test.toml b/acceptance/bundle/telemetry/config-remote-sync-error/out.test.toml
new file mode 100644
index 00000000000..65156e0457c
--- /dev/null
+++ b/acceptance/bundle/telemetry/config-remote-sync-error/out.test.toml
@@ -0,0 +1,3 @@
+Local = true
+Cloud = false
+EnvMatrix.DATABRICKS_BUNDLE_ENGINE = ["terraform"]
diff --git a/acceptance/bundle/telemetry/config-remote-sync-error/output.txt b/acceptance/bundle/telemetry/config-remote-sync-error/output.txt
new file mode 100644
index 00000000000..03e421aaa45
--- /dev/null
+++ b/acceptance/bundle/telemetry/config-remote-sync-error/output.txt
@@ -0,0 +1,11 @@
+
+>>> errcode [CLI] bundle config-remote-sync
+Error: failed to detect changes: state snapshot not available: resources state snapshot not found remotely at resources-config-sync-snapshot.json: state snapshot not found
+
+Exit code: 1
+
+>>> cat out.requests.txt
+{
+  "engine": "terraform",
+  "error_category": "STATE_NOT_FOUND"
+}
diff --git a/acceptance/bundle/telemetry/config-remote-sync-error/script b/acceptance/bundle/telemetry/config-remote-sync-error/script
new file mode 100644
index 00000000000..e48fb6ff123
--- /dev/null
+++ b/acceptance/bundle/telemetry/config-remote-sync-error/script
@@ -0,0 +1,7 @@
+# Running config-remote-sync without a prior deploy: the state snapshot does
+# not exist, so the command fails and telemetry reports STATE_NOT_FOUND.
+trace errcode $CLI bundle config-remote-sync
+
+trace cat out.requests.txt | jq 'select(has("path") and .path == "/telemetry-ext") | .body.protoLogs[] | fromjson | .entry.databricks_cli_log.bundle_config_remote_sync_event | select(. != null)'
+
+rm out.requests.txt
diff --git a/acceptance/bundle/telemetry/config-remote-sync-error/test.toml b/acceptance/bundle/telemetry/config-remote-sync-error/test.toml
new file mode 100644
index 00000000000..a7617afecd5
--- /dev/null
+++ b/acceptance/bundle/telemetry/config-remote-sync-error/test.toml
@@ -0,0 +1,4 @@
+# Running without a prior deploy only fails with STATE_NOT_FOUND on the
+# terraform engine (the snapshot pull path); pin the matrix accordingly.
+[EnvMatrix]
+  DATABRICKS_BUNDLE_ENGINE = ["terraform"]
diff --git a/acceptance/bundle/telemetry/config-remote-sync/databricks.yml b/acceptance/bundle/telemetry/config-remote-sync/databricks.yml
new file mode 100644
index 00000000000..543dc4129bd
--- /dev/null
+++ b/acceptance/bundle/telemetry/config-remote-sync/databricks.yml
@@ -0,0 +1,11 @@
+bundle:
+  name: config-remote-sync-telemetry
+
+resources:
+  jobs:
+    foo:
+      name: test job
+      tasks:
+        - task_key: main
+          notebook_task:
+            notebook_path: /Workspace/Users/tester@databricks.com/notebook
diff --git a/acceptance/bundle/telemetry/config-remote-sync/out.test.toml b/acceptance/bundle/telemetry/config-remote-sync/out.test.toml
new file mode 100644
index 00000000000..e90b6d5d1ba
--- /dev/null
+++ b/acceptance/bundle/telemetry/config-remote-sync/out.test.toml
@@ -0,0 +1,3 @@
+Local = true
+Cloud = false
+EnvMatrix.DATABRICKS_BUNDLE_ENGINE = ["direct"]
diff --git a/acceptance/bundle/telemetry/config-remote-sync/output.txt b/acceptance/bundle/telemetry/config-remote-sync/output.txt
new file mode 100644
index 00000000000..8886bae291a
--- /dev/null
+++ b/acceptance/bundle/telemetry/config-remote-sync/output.txt
@@ -0,0 +1,29 @@
+
+>>> [CLI] bundle deploy
+Uploading bundle files to /Workspace/Users/[USERNAME]/.bundle/config-remote-sync-telemetry/default/files...
+Deploying resources...
+Updating deployment state...
+Deployment complete!
+
+>>> [CLI] bundle config-remote-sync
+Detected changes in 1 resource(s):
+
+Resource: resources.jobs.foo
+  name: replace
+
+
+
+>>> cat out.requests.txt
+{
+  "engine": "direct",
+  "changes_total": 1,
+  "replace_count": 1,
+  "resource_changes": [
+    {
+      "resource_type": "jobs",
+      "changes_count": 1,
+      "replace_count": 1
+    }
+  ],
+  "files_changed_count": 1
+}
diff --git a/acceptance/bundle/telemetry/config-remote-sync/script b/acceptance/bundle/telemetry/config-remote-sync/script
new file mode 100644
index 00000000000..18247c96ce6
--- /dev/null
+++ b/acceptance/bundle/telemetry/config-remote-sync/script
@@ -0,0 +1,12 @@
+trace $CLI bundle deploy
+
+job_id="$(read_id.py foo)"
+edit_resource.py jobs $job_id <<EOF
+r["name"] = "renamed remotely"
+EOF
+
+trace $CLI bundle config-remote-sync
+
+trace cat out.requests.txt | jq 'select(has("path") and .path == "/telemetry-ext") | .body.protoLogs[] | fromjson | .entry.databricks_cli_log.bundle_config_remote_sync_event | select(. != null)'
+
+rm out.requests.txt
diff --git a/acceptance/bundle/telemetry/config-remote-sync/test.toml b/acceptance/bundle/telemetry/config-remote-sync/test.toml
new file mode 100644
index 00000000000..32d160d3358
--- /dev/null
+++ b/acceptance/bundle/telemetry/config-remote-sync/test.toml
@@ -0,0 +1,4 @@
+# The telemetry event includes the engine name, so outputs diverge between
+# engines; pin to direct (the default for new bundles).
+[EnvMatrix]
+  DATABRICKS_BUNDLE_ENGINE = ["direct"]
diff --git a/bundle/configsync/diff.go b/bundle/configsync/diff.go
index 4a0b4f01ca3..95ff76e57a9 100644
--- a/bundle/configsync/diff.go
+++ b/bundle/configsync/diff.go
@@ -205,7 +205,9 @@ func ensureSnapshotAvailable(ctx context.Context, b *bundle.Bundle, engine engin
 	r, err := f.Read(ctx, remotePathSnapshot)
 	if err != nil {
 		if errors.Is(err, fs.ErrNotExist) {
-			return fmt.Errorf("resources state snapshot not found remotely at %s", remotePathSnapshot)
+			// Wrap the sentinel so callers can classify this failure
+			// (telemetry reports it as STATE_NOT_FOUND).
+			return fmt.Errorf("resources state snapshot not found remotely at %s: %w", remotePathSnapshot, ErrStateSnapshotNotFound)
 		}
 		return fmt.Errorf("reading remote snapshot: %w", err)
 	}
diff --git a/bundle/configsync/telemetry.go b/bundle/configsync/telemetry.go
new file mode 100644
index 00000000000..a756d7fb9c9
--- /dev/null
+++ b/bundle/configsync/telemetry.go
@@ -0,0 +1,149 @@
+package configsync
+
+import (
+	"context"
+	"errors"
+	"slices"
+	"strings"
+
+	"github.com/databricks/cli/bundle/config/engine"
+	"github.com/databricks/cli/libs/telemetry"
+	"github.com/databricks/cli/libs/telemetry/protos"
+)
+
+// ErrStateSnapshotNotFound indicates the deployed state snapshot required for
+// change detection does not exist (the bundle was likely never deployed).
+var ErrStateSnapshotNotFound = errors.New("state snapshot not found")
+
+// Stats accumulates aggregate counters for a single config-remote-sync run.
+// All values are counts, booleans, or enumerated categories; no resource
+// names, paths, or configuration values are ever recorded.
+type Stats struct {
+	Save   bool
+	Engine engine.EngineType
+
+	ChangesTotal int64
+	AddCount     int64
+	ReplaceCount int64
+	RemoveCount  int64
+
+	// Keyed by resource type (e.g. "jobs"), as parsed from change keys like
+	// "resources.jobs.foo".
+	PerResourceType map[string]*protos.BundleConfigRemoteSyncResourceChanges
+
+	FilesChangedCount int64
+	FilesWrittenCount int64
+
+	Restore RestoreStats
+
+	RawValuesWithVarSyntax int64
+
+	ErrorCategory protos.BundleConfigRemoteSyncErrorCategory
+}
+
+// RestoreStats counts variable-reference restorations by mechanism.
+type RestoreStats struct {
+	Kept         int64
+	Compound     int64
+	Retargeted   int64
+	FromSiblings int64
+}
+
+// CollectChangeStats fills change counters from the raw (pre-restoration)
+// detected changes.
+func (s *Stats) CollectChangeStats(changes Changes) {
+	if s.PerResourceType == nil {
+		s.PerResourceType = make(map[string]*protos.BundleConfigRemoteSyncResourceChanges)
+	}
+	for resourceKey, resourceChanges := range changes {
+		perType := s.PerResourceType[resourceTypeFromKey(resourceKey)]
+		if perType == nil {
+			perType = &protos.BundleConfigRemoteSyncResourceChanges{ResourceType: resourceTypeFromKey(resourceKey)}
+			s.PerResourceType[perType.ResourceType] = perType
+		}
+		// Only Add/Replace/Remove reach this function: DetectChanges filters
+		// out Skip operations and convertChangeDesc never produces Unknown,
+		// so the totals always equal the per-operation breakdown.
+		for _, change := range resourceChanges {
+			s.ChangesTotal++
+			perType.ChangesCount++
+			switch change.Operation {
+			case OperationAdd:
+				s.AddCount++
+				perType.AddCount++
+			case OperationReplace:
+				s.ReplaceCount++
+				perType.ReplaceCount++
+			case OperationRemove:
+				s.RemoveCount++
+				perType.RemoveCount++
+			case OperationUnknown, OperationSkip:
+			}
+			s.RawValuesWithVarSyntax += countVarSyntax(change.Value)
+		}
+	}
+}
+
+// resourceTypeFromKey extracts the resource type from a change key like
+// "resources.jobs.foo". Only the type segment is recorded; resource keys are
+// never logged.
+func resourceTypeFromKey(resourceKey string) string {
+	parts := strings.SplitN(resourceKey, ".", 3)
+	if len(parts) < 2 || parts[0] != "resources" {
+		return "unknown"
+	}
+	return parts[1]
+}
+
+// countVarSyntax counts string leaves containing the literal "${" sequence.
+// Such values are written to YAML verbatim and are subject to interpolation
+// on the next deploy, so they measure exposure to escaping issues.
+func countVarSyntax(value any) int64 {
+	var n int64
+	switch v := value.(type) {
+	case string:
+		if strings.Contains(v, "${") {
+			n++
+		}
+	case map[string]any:
+		for _, val := range v {
+			n += countVarSyntax(val)
+		}
+	case []any:
+		for _, val := range v {
+			n += countVarSyntax(val)
+		}
+	}
+	return n
+}
+
+// LogTelemetry emits the BundleConfigRemoteSyncEvent for this run.
+func (s *Stats) LogTelemetry(ctx context.Context) {
+	resourceChanges := make([]protos.BundleConfigRemoteSyncResourceChanges, 0, len(s.PerResourceType))
+	for _, perType := range s.PerResourceType {
+		resourceChanges = append(resourceChanges, *perType)
+	}
+	slices.SortFunc(resourceChanges, func(a, b protos.BundleConfigRemoteSyncResourceChanges) int {
+		return strings.Compare(a.ResourceType, b.ResourceType)
+	})
+
+	telemetry.Log(ctx, protos.DatabricksCliLog{
+		BundleConfigRemoteSyncEvent: &protos.BundleConfigRemoteSyncEvent{
+			Save:                   s.Save,
+			Engine:                 string(s.Engine),
+			ChangesTotal:           s.ChangesTotal,
+			AddCount:               s.AddCount,
+			ReplaceCount:           s.ReplaceCount,
+			RemoveCount:            s.RemoveCount,
+			ResourceChanges:        resourceChanges,
+			FilesChangedCount:      s.FilesChangedCount,
+			FilesWrittenCount:      s.FilesWrittenCount,
+			RefsKept:               s.Restore.Kept,
+			RefsCompound:           s.Restore.Compound,
+			RefsRetargeted:         s.Restore.Retargeted,
+			RefsFromSiblings:       s.Restore.FromSiblings,
+			RawValuesWithVarSyntax: s.RawValuesWithVarSyntax,
+			ErrorCategory:          s.ErrorCategory,
+		},
+	})
+}
diff --git a/bundle/configsync/telemetry_test.go b/bundle/configsync/telemetry_test.go
new file mode 100644
index 00000000000..550102a3afd
--- /dev/null
+++ b/bundle/configsync/telemetry_test.go
@@ -0,0 +1,96 @@
+package configsync
+
+import (
+	"testing"
+
+	"github.com/databricks/cli/libs/dyn"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCollectChangeStats(t *testing.T) {
+	changes := Changes{
+		"resources.jobs.foo": {
+			"name":                   {Operation: OperationReplace, Value: "new name"},
+			"tasks[0].notebook_task": {Operation: OperationAdd, Value: map[string]any{"base_parameters": map[string]any{"p": "${workspace.file_path}/x"}}},
+			"timeout_seconds":        {Operation: OperationRemove},
+		},
+		"resources.jobs.bar": {
+			"name": {Operation: OperationReplace, Value: "other"},
+		},
+		"resources.dashboards.dash": {
+			"etag": {Operation: OperationAdd, Value: "123456"},
+		},
+	}
+
+	var stats Stats
+	stats.CollectChangeStats(changes)
+
+	assert.Equal(t, int64(5), stats.ChangesTotal)
+	assert.Equal(t, int64(2), stats.AddCount)
+	assert.Equal(t, int64(2), stats.ReplaceCount)
+	assert.Equal(t, int64(1), stats.RemoveCount)
+	assert.Equal(t, int64(1), stats.RawValuesWithVarSyntax)
+
+	jobs := stats.PerResourceType["jobs"]
+	assert.Equal(t, int64(4), jobs.ChangesCount)
+	assert.Equal(t, int64(1), jobs.AddCount)
+	assert.Equal(t, int64(2), jobs.ReplaceCount)
+	assert.Equal(t, int64(1), jobs.RemoveCount)
+
+	dashboards := stats.PerResourceType["dashboards"]
+	assert.Equal(t, int64(1), dashboards.ChangesCount)
+	assert.Equal(t, int64(1), dashboards.AddCount)
+}
+
+func TestResourceTypeFromKey(t *testing.T) {
+	assert.Equal(t, "jobs", resourceTypeFromKey("resources.jobs.foo"))
+	assert.Equal(t, "dashboards", resourceTypeFromKey("resources.dashboards.a.b"))
+	assert.Equal(t, "unknown", resourceTypeFromKey("variables.foo"))
+	assert.Equal(t, "unknown", resourceTypeFromKey("resources"))
+}
+
+func TestCountVarSyntax(t *testing.T) {
+	assert.Equal(t, int64(0), countVarSyntax("plain"))
+	assert.Equal(t, int64(1), countVarSyntax("${var.x}"))
+	assert.Equal(t, int64(1), countVarSyntax("prefix ${ suffix"))
+	assert.Equal(t, int64(2), countVarSyntax(map[string]any{
+		"a": "${var.x}",
+		"b": []any{"${incomplete", "ok", int64(5)},
+	}))
+}
+
+func TestRestoreStatsCounters(t *testing.T) {
+	resolved := dyn.V(map[string]dyn.Value{
+		"variables": dyn.V(map[string]dyn.Value{
+			"region": dyn.V(map[string]dyn.Value{"value": dyn.V("us-east-1")}),
+			"other":  dyn.V(map[string]dyn.Value{"value": dyn.V("eu-west-1")}),
+		}),
+	})
+
+	// Original pure ref still matching: counted as kept.
+	var kept RestoreStats
+	result := restoreOriginalRefs("us-east-1", dyn.V("${var.region}"), resolved, &kept)
+	assert.Equal(t, "${var.region}", result)
+	assert.Equal(t, RestoreStats{Kept: 1}, kept)
+
+	// Pure ref whose value changed to another variable's value: re-targeted.
+	var retargeted RestoreStats
+	result = restoreOriginalRefs("eu-west-1", dyn.V("${var.region}"), resolved, &retargeted)
+	assert.Equal(t, "${var.other}", result)
+	assert.Equal(t, RestoreStats{Retargeted: 1}, retargeted)
+
+	// New sequence element leaf restored from a sibling reference.
+	siblings := []dyn.Value{
+		dyn.V(map[string]dyn.Value{"region": dyn.V("${var.region}")}),
+	}
+	var fromSiblings RestoreStats
+	resultMap := restoreFromSiblings(map[string]any{"region": "us-east-1"}, siblings, resolved, &fromSiblings).(map[string]any)
+	assert.Equal(t, "${var.region}", resultMap["region"])
+	assert.Equal(t, RestoreStats{FromSiblings: 1}, fromSiblings)
+
+	// Hardcoded value: nothing restored, nothing counted.
+	var none RestoreStats
+	result = restoreOriginalRefs("hardcoded", dyn.V("hardcoded"), resolved, &none)
+	assert.Equal(t, "hardcoded", result)
+	assert.Equal(t, RestoreStats{}, none)
+}
diff --git a/bundle/configsync/variables.go b/bundle/configsync/variables.go
index 0745bfba43b..d28eee3c7b6 100644
--- a/bundle/configsync/variables.go
+++ b/bundle/configsync/variables.go
@@ -51,7 +51,12 @@ var varPrefix = dyn.NewPath(dyn.Key("var"))
 // view where ${var.X} and ${resources.X.Y.id} references are still literal
 // strings — enabling correct sibling lookup even for sequences split across
 // files via target overrides.
-func RestoreVariableReferences(ctx context.Context, b *bundle.Bundle, fieldChanges []FieldChange) error {
+// Restoration counts by mechanism are accumulated into stats (used for
+// telemetry); pass nil when counters are not needed.
+func RestoreVariableReferences(ctx context.Context, b *bundle.Bundle, fieldChanges []FieldChange, stats *RestoreStats) error {
+	if stats == nil {
+		stats = &RestoreStats{}
+	}
 	preResolved := loadPreResolvedConfig(ctx, b)
 	if !preResolved.IsValid() {
 		return errors.New("pre-resolved config unavailable; variable-backed fields will be hardcoded")
@@ -95,13 +100,13 @@ func RestoreVariableReferences(ctx context.Context, b *bundle.Bundle, fieldChang
 			if !ok {
 				continue
 			}
-			newValue = restoreOriginalRefs(fc.Change.Value, fieldValue, resolved)
+			newValue = restoreOriginalRefs(fc.Change.Value, fieldValue, resolved, stats)
 		case OperationAdd:
 			siblings, ok := sequenceSiblings(preResolved, fc.FieldCandidates)
 			if !ok {
 				continue
 			}
-			newValue = restoreFromSiblings(fc.Change.Value, siblings, resolved)
+			newValue = restoreFromSiblings(fc.Change.Value, siblings, resolved, stats)
 		case OperationUnknown, OperationRemove, OperationSkip:
 			continue
 		}
@@ -231,19 +236,22 @@ func resolveReferencePath(refStr string) (dyn.Path, bool) {
 // new value, falls back to a global lookup: if the new value uniquely matches
 // a different variable, that variable is used instead. The field's prior use
 // of a variable is the false-positive guard.
-func restoreOriginalRefs(value any, preResolved, resolved dyn.Value) any {
+func restoreOriginalRefs(value any, preResolved, resolved dyn.Value, stats *RestoreStats) any {
 	switch v := value.(type) {
 	case string, bool, int64:
 		if ref, ok := matchOriginalRef(value, preResolved, resolved); ok {
+			stats.Kept++
 			return ref
 		}
 		if s, ok := value.(string); ok {
 			if restored, ok := restoreCompoundInterpolation(s, preResolved, resolved); ok {
+				stats.Compound++
 				return restored
 			}
 		}
 		if isPureVarRef(preResolved) {
 			if ref, ok := matchAnyVariable(value, resolved); ok {
+				stats.Retargeted++
 				return ref
 			}
 		}
@@ -258,7 +266,7 @@ func restoreOriginalRefs(value any, preResolved, resolved dyn.Value) any {
 					childPre = p.Value
 				}
 			}
-			v[key] = restoreOriginalRefs(val, childPre, resolved)
+			v[key] = restoreOriginalRefs(val, childPre, resolved, stats)
 		}
 		return v
 
@@ -269,7 +277,7 @@ func restoreOriginalRefs(value any, preResolved, resolved dyn.Value) any {
 			if i < len(preSeq) {
 				childPre = preSeq[i]
 			}
-			v[i] = restoreOriginalRefs(val, childPre, resolved)
+			v[i] = restoreOriginalRefs(val, childPre, resolved, stats)
 		}
 		return v
 
@@ -283,11 +291,11 @@ func restoreOriginalRefs(value any, preResolved, resolved dyn.Value) any {
 // relative path: if exactly one unique pure variable reference across siblings
 // resolves to the leaf value, that reference is substituted. Multiple
 // different matching references are treated as ambiguous and skipped.
-func restoreFromSiblings(value any, siblings []dyn.Value, resolved dyn.Value) any {
-	return restoreFromSiblingsAt(value, siblings, resolved, dyn.EmptyPath)
+func restoreFromSiblings(value any, siblings []dyn.Value, resolved dyn.Value, stats *RestoreStats) any {
+	return restoreFromSiblingsAt(value, siblings, resolved, dyn.EmptyPath, stats)
 }
 
-func restoreFromSiblingsAt(value any, siblings []dyn.Value, resolved dyn.Value, relPath dyn.Path) any {
+func restoreFromSiblingsAt(value any, siblings []dyn.Value, resolved dyn.Value, relPath dyn.Path, stats *RestoreStats) any {
 	switch v := value.(type) {
 	case string, bool, int64:
 		refs := map[string]struct{}{}
@@ -325,6 +333,7 @@ func restoreFromSiblingsAt(value any, siblings []dyn.Value, resolved dyn.Value,
 		}
 		if len(refs) == 1 {
 			for ref := range refs {
+				stats.FromSiblings++
 				return ref
 			}
 		}
@@ -332,13 +341,13 @@ func restoreFromSiblingsAt(value any, siblings []dyn.Value, resolved dyn.Value,
 
 	case map[string]any:
 		for key, val := range v {
-			v[key] = restoreFromSiblingsAt(val, siblings, resolved, relPath.Append(dyn.Key(key)))
+			v[key] = restoreFromSiblingsAt(val, siblings, resolved, relPath.Append(dyn.Key(key)), stats)
 		}
 		return v
 
 	case []any:
 		for i, val := range v {
-			v[i] = restoreFromSiblingsAt(val, siblings, resolved, relPath.Append(dyn.Index(i)))
+			v[i] = restoreFromSiblingsAt(val, siblings, resolved, relPath.Append(dyn.Index(i)), stats)
 		}
 		return v
 
diff --git a/bundle/configsync/variables_test.go b/bundle/configsync/variables_test.go
index 9dd94c0cfb7..15f11d5eb3c 100644
--- a/bundle/configsync/variables_test.go
+++ b/bundle/configsync/variables_test.go
@@ -19,7 +19,7 @@ func TestRestoreOriginalRefs_HardcodedFieldNotRewritten(t *testing.T) {
 	})
 	// Even though "main" matches ${var.region}, restoreOriginalRefs must NOT
 	// rewrite it — the original was hardcoded.
-	result := restoreOriginalRefs("main", preResolved, resolved)
+	result := restoreOriginalRefs("main", preResolved, resolved, &RestoreStats{})
 	assert.Equal(t, "main", result)
 }
 
@@ -44,7 +44,7 @@ func TestRestoreFromSiblings_ValueMatchesVariableButDifferentPath(t *testing.T)
 		"task_key":           "other",
 		"min_retry_interval": int64(5),
 	}
-	result := restoreFromSiblings(value, siblings, resolved).(map[string]any)
+	result := restoreFromSiblings(value, siblings, resolved, &RestoreStats{}).(map[string]any)
 	assert.Equal(t, "other", result["task_key"])
 	assert.Equal(t, int64(5), result["min_retry_interval"])
 }
@@ -64,7 +64,7 @@ func TestRestoreFromSiblings_AmbiguousAcrossSiblings(t *testing.T) {
 		}),
 	})
 	value := map[string]any{"default": "raw_data"}
-	result := restoreFromSiblings(value, siblings, resolved).(map[string]any)
+	result := restoreFromSiblings(value, siblings, resolved, &RestoreStats{}).(map[string]any)
 	assert.Equal(t, "raw_data", result["default"])
 }
 
@@ -108,7 +108,7 @@ func TestRestoreCompoundInterpolation(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result := restoreOriginalRefs(tt.remote, dyn.V(tt.template), resolved)
+			result := restoreOriginalRefs(tt.remote, dyn.V(tt.template), resolved, &RestoreStats{})
 			assert.Equal(t, tt.want, result)
 		})
 	}
diff --git a/cmd/bundle/config_remote_sync.go b/cmd/bundle/config_remote_sync.go
index c50e613d71a..9825b59764b 100644
--- a/cmd/bundle/config_remote_sync.go
+++ b/cmd/bundle/config_remote_sync.go
@@ -12,8 +12,10 @@ import (
 	"github.com/databricks/cli/bundle/statemgmt"
 	"github.com/databricks/cli/cmd/bundle/utils"
 	"github.com/databricks/cli/cmd/root"
+	"github.com/databricks/cli/libs/cmdctx"
 	"github.com/databricks/cli/libs/flags"
 	"github.com/databricks/cli/libs/log"
+	"github.com/databricks/cli/libs/telemetry/protos"
 	"github.com/spf13/cobra"
 )
 
@@ -46,6 +48,18 @@ Examples:
 			return errors.New("config-remote-sync command is not supported on Windows")
 		}
 
+		stats := configsync.Stats{Save: save}
+
+		// Emit telemetry on every exit path, including failures inside
+		// ProcessBundleRet before PostStateFunc runs. Skip when no auth config
+		// was resolved: without it the upload at the end of the command
+		// lifecycle has no workspace to send to.
+		defer func() {
+			if cmdctx.HasConfigUsed(cmd.Context()) {
+				stats.LogTelemetry(cmd.Context())
+			}
+		}()
+
 		_, _, err := utils.ProcessBundleRet(cmd, utils.ProcessOptions{
 			ReadState:  true,
 			Build:      true,
@@ -54,29 +68,41 @@ Examples:
 				b.SkipLocalFileValidation = true
 			},
 			PostStateFunc: func(ctx context.Context, b *bundle.Bundle, stateDesc *statemgmt.StateDesc) error {
+				stats.Engine = stateDesc.Engine
+
 				changes, err := configsync.DetectChanges(ctx, b, stateDesc.Engine)
 				if err != nil {
+					stats.ErrorCategory = protos.BundleConfigRemoteSyncErrorCategoryDetectChangesFailed
+					if errors.Is(err, configsync.ErrStateSnapshotNotFound) {
+						stats.ErrorCategory = protos.BundleConfigRemoteSyncErrorCategoryStateNotFound
+					}
 					return fmt.Errorf("failed to detect changes: %w", err)
 				}
+				stats.CollectChangeStats(changes)
 
 				fieldChanges, err := configsync.ResolveChanges(ctx, b, changes)
 				if err != nil {
+					stats.ErrorCategory = protos.BundleConfigRemoteSyncErrorCategoryResolveFailed
 					return fmt.Errorf("failed to resolve field changes: %w", err)
 				}
 
-				if err := configsync.RestoreVariableReferences(ctx, b, fieldChanges); err != nil {
+				if err := configsync.RestoreVariableReferences(ctx, b, fieldChanges, &stats.Restore); err != nil {
 					log.Warnf(ctx, "variable restoration skipped: %v", err)
 				}
 
 				files, err := configsync.ApplyChangesToYAML(ctx, b, fieldChanges)
 				if err != nil {
+					stats.ErrorCategory = protos.BundleConfigRemoteSyncErrorCategoryYamlApplyFailed
 					return fmt.Errorf("failed to generate YAML files: %w", err)
 				}
+				stats.FilesChangedCount = int64(len(files))
 
 				if save {
 					if err := configsync.SaveFiles(ctx, b, files); err != nil {
+						stats.ErrorCategory = protos.BundleConfigRemoteSyncErrorCategorySaveFailed
 						return fmt.Errorf("failed to save files: %w", err)
 					}
+					stats.FilesWrittenCount = int64(len(files))
 				}
 
 				var result []byte
@@ -87,6 +113,7 @@ Examples:
 					}
 					result, err = json.MarshalIndent(diffOutput, "", "  ")
 					if err != nil {
+						stats.ErrorCategory = protos.BundleConfigRemoteSyncErrorCategoryOutputFailed
 						return fmt.Errorf("failed to marshal output: %w", err)
 					}
 				} else if root.OutputType(cmd) == flags.OutputText {
@@ -99,6 +126,9 @@ Examples:
 				return nil
 			},
 		})
+		if err != nil && stats.ErrorCategory == "" {
+			stats.ErrorCategory = protos.BundleConfigRemoteSyncErrorCategoryBundleLoadFailed
+		}
 		return err
 	}
 
diff --git a/libs/telemetry/protos/bundle_config_remote_sync.go b/libs/telemetry/protos/bundle_config_remote_sync.go
new file mode 100644
index 00000000000..0db83b601d8
--- /dev/null
+++ b/libs/telemetry/protos/bundle_config_remote_sync.go
@@ -0,0 +1,73 @@
+package protos
+
+type BundleConfigRemoteSyncErrorCategory string
+
+const (
+	BundleConfigRemoteSyncErrorCategoryUnspecified         BundleConfigRemoteSyncErrorCategory = "TYPE_UNSPECIFIED"
+	BundleConfigRemoteSyncErrorCategoryUnsupportedOS       BundleConfigRemoteSyncErrorCategory = "UNSUPPORTED_OS"
+	BundleConfigRemoteSyncErrorCategoryBundleLoadFailed    BundleConfigRemoteSyncErrorCategory = "BUNDLE_LOAD_FAILED"
+	BundleConfigRemoteSyncErrorCategoryStateNotFound       BundleConfigRemoteSyncErrorCategory = "STATE_NOT_FOUND"
+	BundleConfigRemoteSyncErrorCategoryDetectChangesFailed BundleConfigRemoteSyncErrorCategory = "DETECT_CHANGES_FAILED"
+	BundleConfigRemoteSyncErrorCategoryResolveFailed       BundleConfigRemoteSyncErrorCategory = "RESOLVE_FAILED"
+	BundleConfigRemoteSyncErrorCategoryYamlApplyFailed     BundleConfigRemoteSyncErrorCategory = "YAML_APPLY_FAILED"
+	BundleConfigRemoteSyncErrorCategorySaveFailed          BundleConfigRemoteSyncErrorCategory = "SAVE_FAILED"
+	BundleConfigRemoteSyncErrorCategoryOutputFailed        BundleConfigRemoteSyncErrorCategory = "OUTPUT_FAILED"
+)
+
+// BundleConfigRemoteSyncEvent is emitted on every execution of the
+// `databricks bundle config-remote-sync` command.
+//
+// All fields are aggregate counts, booleans, or system-defined categories.
+// No resource names, keys, field paths, file paths, or configuration values
+// are logged.
+type BundleConfigRemoteSyncEvent struct {
+	// Whether the command was invoked with --save (config files written to
+	// disk) as opposed to diff-only mode.
+	Save bool `json:"save,omitempty"`
+
+	// Deployment engine the state was read from: "direct" or "terraform".
+	Engine string `json:"engine,omitempty"`
+
+	// Total number of field-level changes detected between the deployed state
+	// and the current remote state, across all resources.
+	ChangesTotal int64 `json:"changes_total,omitempty"`
+
+	// Number of detected changes by operation type.
+	AddCount     int64 `json:"add_count,omitempty"`
+	ReplaceCount int64 `json:"replace_count,omitempty"`
+	RemoveCount  int64 `json:"remove_count,omitempty"`
+
+	// One entry per resource type that has at least one detected change.
+	ResourceChanges []BundleConfigRemoteSyncResourceChanges `json:"resource_changes,omitempty"`
+
+	// Number of configuration files that would be modified by the detected
+	// changes, and the number actually written to disk (--save only).
+	FilesChangedCount int64 `json:"files_changed_count,omitempty"`
+	FilesWrittenCount int64 `json:"files_written_count,omitempty"`
+
+	// Variable-reference restoration statistics.
+	RefsKept         int64 `json:"refs_kept,omitempty"`
+	RefsCompound     int64 `json:"refs_compound,omitempty"`
+	RefsRetargeted   int64 `json:"refs_retargeted,omitempty"`
+	RefsFromSiblings int64 `json:"refs_from_siblings,omitempty"`
+
+	// Number of detected remote string values that contain the literal
+	// character sequence "${". The values themselves are not logged.
+	RawValuesWithVarSyntax int64 `json:"raw_values_with_var_syntax,omitempty"`
+
+	// Category of the failure when the command exits with an error.
+	// Unset on success.
+	ErrorCategory BundleConfigRemoteSyncErrorCategory `json:"error_category,omitempty"`
+}
+
+// BundleConfigRemoteSyncResourceChanges holds field-level change counts for a
+// single resource type within one config-remote-sync run.
+type BundleConfigRemoteSyncResourceChanges struct {
+	// Resource type name, e.g. "jobs", "pipelines", "dashboards".
+	ResourceType string `json:"resource_type,omitempty"`
+
+	ChangesCount int64 `json:"changes_count,omitempty"`
+	AddCount     int64 `json:"add_count,omitempty"`
+	ReplaceCount int64 `json:"replace_count,omitempty"`
+	RemoveCount  int64 `json:"remove_count,omitempty"`
+}
diff --git a/libs/telemetry/protos/frontend_log.go b/libs/telemetry/protos/frontend_log.go
index 816297a8eef..676f72055da 100644
--- a/libs/telemetry/protos/frontend_log.go
+++ b/libs/telemetry/protos/frontend_log.go
@@ -16,8 +16,9 @@ type FrontendLogEntry struct {
 type DatabricksCliLog struct {
 	ExecutionContext *ExecutionContext `json:"execution_context,omitempty"`
 
-	CliTestEvent      *CliTestEvent      `json:"cli_test_event,omitempty"`
-	BundleInitEvent   *BundleInitEvent   `json:"bundle_init_event,omitempty"`
-	BundleDeployEvent *BundleDeployEvent `json:"bundle_deploy_event,omitempty"`
-	SshTunnelEvent    *SshTunnelEvent    `json:"ssh_tunnel_event,omitempty"`
+	CliTestEvent                *CliTestEvent                `json:"cli_test_event,omitempty"`
+	BundleInitEvent             *BundleInitEvent             `json:"bundle_init_event,omitempty"`
+	BundleDeployEvent           *BundleDeployEvent           `json:"bundle_deploy_event,omitempty"`
+	SshTunnelEvent              *SshTunnelEvent              `json:"ssh_tunnel_event,omitempty"`
+	BundleConfigRemoteSyncEvent *BundleConfigRemoteSyncEvent `json:"bundle_config_remote_sync_event,omitempty"`
 }