fix(rename): skip stateless objects in PathsGenerator to prevent panic

When a manifest entry exists for a config that has neither local nor
remote state (e.g. an orphaned scheduler config after its target
orchestrator was deleted), PathsGenerator.doUpdate called
LocalOrRemoteState() which panicked unconditionally.

Two guards added to doUpdate:
1. Skip the object itself when both HasLocalState and HasRemoteState
   are false.
2. Skip the object when its parent is stateless, since a valid path
   cannot be resolved without a resolved parent.

Reproduces the crash in PSGO-233 / SUPPORT-15941 where kbc pull
panicked on "object Local or Remote state must be set" for clients
with an existing local manifest containing an orphaned scheduler entry.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: Matovidlo

internal/pkg/plan/rename/plan_test.go

@@ -83,6 +83,85 @@ func TestRenameAllPlan(t *testing.T) {
 	}, plan)
 }
 
+// TestRenameAllPlan_StatelessParentSkipped verifies that NewPlan does not panic
+// when a config with remote state has a parent that is stateless in the registry.
+// This reproduces the production scenario from PSGO-233: a scheduler config has
+// a SchedulerForRelation pointing to an orchestrator whose manifest entry is
+// orphaned (nil Local and nil Remote). State.All() returns the scheduler (has
+// remote state) but not the orchestrator, so doUpdate reaches the parent via
+// MustGet and must skip gracefully without calling LocalOrRemoteState().
+func TestRenameAllPlan_StatelessParentSkipped(t *testing.T) {
+	t.Parallel()
+	_, testFile, _, _ := runtime.Caller(0)
+	testDir := filesystem.Dir(testFile)
+	fs := testFs(t, filesystem.Join(testDir, "..", "..", "fixtures", "local", "to-rename"))
+	d := dependencies.NewMocked(t, t.Context())
+
+	getGenericExResponder, err := httpmock.NewJsonResponder(200, map[string]any{
+		"id":   "ex-generic-v2",
+		"type": "extractor",
+		"name": "Generic",
+	})
+	require.NoError(t, err)
+	getMySQLExResponder, err := httpmock.NewJsonResponder(200, map[string]any{
+		"id":   "keboola.ex-db-mysql",
+		"type": "extractor",
+		"name": "MySQL",
+	})
+	require.NoError(t, err)
+	d.MockedHTTPTransport().RegisterResponder("GET", `=~/storage/components/ex-generic-v2`, getGenericExResponder.Once())
+	d.MockedHTTPTransport().RegisterResponder("GET", `=~/storage/components/keboola.ex-db-mysql`, getMySQLExResponder.Once())
+
+	projectState, err := d.MockedProject(fs).LoadState(t.Context(), loadState.Options{LoadLocalState: true}, d)
+	require.NoError(t, err)
+
+	// Stateless orchestrator: in the registry as an orphaned manifest entry, but
+	// both Local and Remote are nil — simulates a deleted orchestrator.
+	orchKey := model.ConfigKey{BranchID: 123, ComponentID: "keboola.orchestrator", ID: "orch-orphaned"}
+	orchState := &model.ConfigState{
+		ConfigManifest: &model.ConfigManifest{
+			ConfigKey: orchKey,
+			Paths: model.Paths{
+				AbsPath: model.NewAbsPath("my-main-branch", "other/keboola.orchestrator/orch-orphaned"),
+			},
+		},
+	}
+
+	// Scheduler with remote state whose SchedulerForRelation parent key points to
+	// the stateless orchestrator. State.All() will include this scheduler (it has
+	// remote state), so doUpdate will recurse into the stateless orchestrator parent.
+	schedulerKey := model.ConfigKey{BranchID: 123, ComponentID: "keboola.scheduler", ID: "sched-for-orch"}
+	schedulerState := &model.ConfigState{
+		ConfigManifest: &model.ConfigManifest{
+			ConfigKey: schedulerKey,
+			Paths: model.Paths{
+				AbsPath: model.NewAbsPath("my-main-branch", "other/keboola.scheduler/sched-for-orch"),
+			},
+		},
+		Remote: &model.Config{
+			ConfigKey: schedulerKey,
+			Relations: model.Relations{
+				&model.SchedulerForRelation{
+					ComponentID: "keboola.orchestrator",
+					ConfigID:    "orch-orphaned",
+				},
+			},
+		},
+	}
+
+	require.NoError(t, projectState.State().Set(orchState))
+	require.NoError(t, projectState.State().Set(schedulerState))
+
+	// NewPlan must not panic; neither orphaned object should appear in rename actions.
+	plan, err := NewPlan(projectState.State())
+	require.NoError(t, err)
+
+	for _, action := range plan.actions {
+		assert.NotEqual(t, action.Manifest.Key(), orchKey)
+		assert.NotEqual(t, action.Manifest.Key(), schedulerKey)
+	}
+}
+
 func testFs(t *testing.T, inputDir string) filesystem.Fs {
 	t.Helper()
 

internal/pkg/state/local/paths.go

@@ -67,6 +67,13 @@ func (g *PathsGenerator) doUpdate(objectState model.ObjectState, origin model.Ke
 		return nil
 	}
 
+	// Orphaned manifest entries have no local or remote state; skip them so
+	// LocalOrRemoteState() does not panic and they are excluded from rename.
+	if !objectState.HasLocalState() && !objectState.HasRemoteState() {
+		g.processed[objectState.Key().String()] = true
+		return nil
+	}
+
 	// Detect cyclic relations
 	if origin != nil && objectState.Key().String() == origin.String() {
 		return errors.Errorf(`a cyclic relation was found when generating path to %s`, origin.Desc())
@@ -93,6 +100,12 @@ func (g *PathsGenerator) doUpdate(objectState model.ObjectState, origin model.Ke
 			return err
 		}
 
+		// Skip if the parent is stateless — its path cannot be resolved.
+		if !parent.HasLocalState() && !parent.HasRemoteState() {
+			g.processed[objectState.Key().String()] = true
+			return nil
+		}
+
 		// Set new parent path
 		manifest.SetParentPath(parent.Path())
 	}