@elevasis/core 0.22.0 → 0.24.0

package/src/organization-model/__tests__/flatten-additive-merge.test.ts

@@ -0,0 +1,362 @@
+import { describe, expect, it } from 'vitest'
+import { DEFAULT_ORGANIZATION_MODEL } from '../defaults'
+import { listDomain } from '../helpers'
+import { resolveOrganizationModel } from '../resolve'
+import type { DeepPartial, OrganizationModel } from '../types'
+
+// ---------------------------------------------------------------------------
+// Step 5 of om-flatten-single-array-domains: lock in additive-by-id merge
+// across all 9 flattened domains.
+//
+// Before the flatten, every domain was `{ field: Entry[] }` and deepMerge's
+// array branch (`Array.isArray(base) -> return override`) caused tenant
+// overrides to wholesale-replace the array. The systems domain needed a
+// special-case mergeSystemsById helper (sidebar-regression-fix.mdx OD1) to
+// produce additive behavior.
+//
+// After the flatten, every domain is `Record<string, Entry>` keyed by id, so
+// deepMerge's object branch (`isPlainObject(base) && isPlainObject(override)
+// -> deepMerge per key`) gives additive-by-id semantics for free.
+//
+// These tests pin that semantic in place. If anyone re-introduces array shape
+// on these domains, or special-cases merge logic, these tests will surface it.
+// ---------------------------------------------------------------------------
+
+describe('flatten: deepMerge produces additive-by-id behavior across all 9 flattened domains', () => {
+  // Phase 4 (D1): 'statuses' top-level field removed from OrganizationModel.
+  // Status data moved into system.content as (schema:status-flow) / (schema:status) nodes.
+  // The remaining 8 domains are all Record<string, Entry> after the flatten.
+  const FLATTENED_DOMAINS = [
+    'systems',
+    'roles',
+    'goals',
+    'customers',
+    'actions',
+    'offerings',
+    'resources',
+    'policies'
+  ] as const
+
+  it.each(FLATTENED_DOMAINS)('%s domain shape is Record<string, Entry>, not an array wrapper', (domain) => {
+    const value = DEFAULT_ORGANIZATION_MODEL[domain]
+    expect(Array.isArray(value)).toBe(false)
+    expect(typeof value).toBe('object')
+    expect(value).not.toBeNull()
+  })
+
+  it('adds a tenant system to the merged record without dropping defaults', () => {
+    const baseSize = Object.keys(DEFAULT_ORGANIZATION_MODEL.systems).length
+
+    const model = resolveOrganizationModel({
+      systems: {
+        'tenant.workspace': {
+          id: 'tenant.workspace',
+          order: 10000,
+          label: 'Tenant Workspace',
+          lifecycle: 'active',
+          path: '/tenant'
+        }
+      }
+    })
+
+    expect(Object.keys(model.systems)).toHaveLength(baseSize + 1)
+    expect(model.systems['tenant.workspace']?.label).toBe('Tenant Workspace')
+    // Default systems survive
+    expect(model.systems['dashboard']).toBeDefined()
+    expect(model.systems['operations']).toBeDefined()
+  })
+
+  it('merges a tenant role additively without clobbering default roles', () => {
+    const baseSize = Object.keys(DEFAULT_ORGANIZATION_MODEL.roles).length
+
+    const model = resolveOrganizationModel({
+      roles: {
+        'role.tenant-lead': {
+          id: 'role.tenant-lead',
+          order: 10000,
+          title: 'Tenant Lead'
+        }
+      }
+    })
+
+    expect(Object.keys(model.roles)).toHaveLength(baseSize + 1)
+    expect(model.roles['role.tenant-lead']?.title).toBe('Tenant Lead')
+  })
+
+  it('merges a tenant action additively while preserving the default action catalog', () => {
+    const baseSize = Object.keys(DEFAULT_ORGANIZATION_MODEL.actions).length
+    expect(baseSize).toBeGreaterThan(0)
+
+    const model = resolveOrganizationModel({
+      actions: {
+        'tenant.custom-action': {
+          id: 'tenant.custom-action',
+          order: 10000,
+          label: 'Custom Action',
+          scope: 'global',
+          resourceId: 'tenant-workflow'
+        }
+      }
+    })
+
+    expect(Object.keys(model.actions)).toHaveLength(baseSize + 1)
+    expect(model.actions['tenant.custom-action']?.label).toBe('Custom Action')
+    expect(model.actions['lead-gen.company.source']).toBeDefined()
+    expect(model.actions['send_reply']).toBeDefined()
+  })
+
+  it('overrides an existing system by id (last write wins on the same map key)', () => {
+    const model = resolveOrganizationModel({
+      systems: {
+        dashboard: {
+          id: 'dashboard',
+          order: 10,
+          label: 'Tenant Dashboard',
+          lifecycle: 'active',
+          path: '/'
+        }
+      }
+    })
+
+    expect(model.systems['dashboard']?.label).toBe('Tenant Dashboard')
+    // Other defaults remain
+    expect(model.systems['operations']).toBeDefined()
+  })
+
+  it('merges nested fields within a single entry deeply (not replacing the whole entry)', () => {
+    // Overriding only `label` on a default system preserves its other fields.
+    const defaultDashboard = DEFAULT_ORGANIZATION_MODEL.systems['dashboard']
+    expect(defaultDashboard).toBeDefined()
+
+    const model = resolveOrganizationModel({
+      systems: {
+        dashboard: {
+          id: 'dashboard',
+          order: defaultDashboard!.order,
+          label: 'Renamed'
+        }
+      }
+    })
+
+    const merged = model.systems['dashboard']
+    expect(merged?.label).toBe('Renamed')
+    // Path from defaults survives because object merge is deep per-key.
+    expect(merged?.path).toBe(defaultDashboard!.path)
+  })
+
+  it('confirms no special-case mergeSystemsById helper exists in resolve.ts', async () => {
+    // The OD1 special case from sidebar-regression-fix.mdx is superseded by
+    // this flatten. If anyone reintroduces it under any of these names,
+    // surface that drift.
+    const source = await import('node:fs/promises').then((fs) =>
+      fs.readFile(new URL('../resolve.ts', import.meta.url), 'utf-8')
+    )
+
+    expect(source).not.toMatch(/mergeSystemsById/)
+    expect(source).not.toMatch(/mergeById/)
+    expect(source).not.toMatch(/mergeRecordById/)
+  })
+
+  it('multiple flattened domains receive independent additive merges in one call', () => {
+    const baseSystems = Object.keys(DEFAULT_ORGANIZATION_MODEL.systems).length
+    const baseRoles = Object.keys(DEFAULT_ORGANIZATION_MODEL.roles).length
+    const baseActions = Object.keys(DEFAULT_ORGANIZATION_MODEL.actions).length
+
+    const model = resolveOrganizationModel({
+      systems: {
+        'tenant.a': { id: 'tenant.a', order: 10000, label: 'A', lifecycle: 'active', path: '/a' }
+      },
+      roles: {
+        'role.a': { id: 'role.a', order: 10000, title: 'A' }
+      },
+      actions: {
+        'tenant.a': {
+          id: 'tenant.a',
+          order: 10000,
+          label: 'A Action',
+          scope: 'global',
+          resourceId: 'a-workflow'
+        }
+      }
+    })
+
+    expect(Object.keys(model.systems)).toHaveLength(baseSystems + 1)
+    expect(Object.keys(model.roles)).toHaveLength(baseRoles + 1)
+    expect(Object.keys(model.actions)).toHaveLength(baseActions + 1)
+  })
+
+  // ---------------------------------------------------------------------------
+  // Override merge edge cases
+  // ---------------------------------------------------------------------------
+
+  it('order override on existing entry takes precedence and re-sorts the listed domain', () => {
+    const override: DeepPartial<OrganizationModel> = {
+      systems: {
+        dashboard: {
+          id: 'dashboard',
+          order: 1000,
+          label: 'Dashboard',
+          lifecycle: 'active',
+          path: '/'
+        }
+      }
+    }
+
+    const resolved = resolveOrganizationModel(override)
+
+    expect(resolved.systems['dashboard']!.order).toBe(1000)
+
+    const listed = listDomain(resolved.systems)
+    const dashboardIndex = listed.findIndex((s) => s.id === 'dashboard')
+    const systemsBefore = listed.filter((s) => s.order < 1000)
+    expect(dashboardIndex).toBeGreaterThan(systemsBefore.length - 1)
+    // All entries with order < 1000 must appear before dashboard in the sorted list
+    systemsBefore.forEach((s) => {
+      expect(listed.indexOf(s)).toBeLessThan(dashboardIndex)
+    })
+  })
+
+  it('override entry omitting order preserves the base order value', () => {
+    const baseOrder = DEFAULT_ORGANIZATION_MODEL.systems['dashboard']!.order
+
+    const override: DeepPartial<OrganizationModel> = {
+      systems: {
+        dashboard: {
+          id: 'dashboard',
+          label: 'Renamed Dashboard'
+        }
+      }
+    }
+
+    const resolved = resolveOrganizationModel(override)
+
+    expect(resolved.systems['dashboard']!.order).toBe(baseOrder)
+    expect(resolved.systems['dashboard']!.label).toBe('Renamed Dashboard')
+  })
+
+  it('throws when system map key does not match the entry id', () => {
+    const badOverride: DeepPartial<OrganizationModel> = {
+      systems: {
+        'wrong-key': {
+          id: 'different-id',
+          order: 10,
+          label: 'Mismatch',
+          lifecycle: 'active',
+          path: '/mismatch'
+        }
+      }
+    }
+
+    expect(() => resolveOrganizationModel(badOverride)).toThrow(/map key/)
+  })
+
+  it('replaces nested arrays rather than merging them', () => {
+    // sales.lead-gen has a top-level `actions` array field on the entry.
+    // deepMerge hits Array.isArray(existing) => returns override value directly.
+    const singleRef = [{ actionId: 'lead-gen.company.source', intent: 'exposes' as const }]
+
+    const override: DeepPartial<OrganizationModel> = {
+      systems: {
+        'sales.lead-gen': {
+          id: 'sales.lead-gen',
+          order: DEFAULT_ORGANIZATION_MODEL.systems['sales.lead-gen']!.order,
+          label: 'Lead Gen',
+          actions: singleRef
+        }
+      }
+    }
+
+    const resolved = resolveOrganizationModel(override)
+    const entry = resolved.systems['sales.lead-gen']!
+
+    expect(entry.actions).toHaveLength(1)
+    expect(entry.actions).toEqual(singleRef)
+  })
+
+  it('empty systems override produces same systems domain as no override', () => {
+    const withEmpty = resolveOrganizationModel({ systems: {} })
+    const withNone = resolveOrganizationModel()
+
+    expect(withEmpty.systems).toEqual(withNone.systems)
+  })
+
+  it('field set to undefined in override is skipped and retains the base value', () => {
+    const basePath = DEFAULT_ORGANIZATION_MODEL.systems['dashboard']!.path
+
+    const override: DeepPartial<OrganizationModel> = {
+      systems: {
+        dashboard: {
+          id: 'dashboard',
+          order: DEFAULT_ORGANIZATION_MODEL.systems['dashboard']!.order,
+          label: 'Dashboard',
+          path: undefined
+        }
+      }
+    }
+
+    const resolved = resolveOrganizationModel(override)
+
+    expect(resolved.systems['dashboard']!.path).toBe(basePath)
+  })
+
+  it('simultaneous override of systems, roles, and actions merges each domain independently without cross-contamination', () => {
+    const baseSystems = Object.keys(DEFAULT_ORGANIZATION_MODEL.systems).length
+    const baseRoles = Object.keys(DEFAULT_ORGANIZATION_MODEL.roles).length
+    const baseActions = Object.keys(DEFAULT_ORGANIZATION_MODEL.actions).length
+    const baseCustomers = DEFAULT_ORGANIZATION_MODEL.customers
+    const baseGoals = DEFAULT_ORGANIZATION_MODEL.goals
+
+    const model = resolveOrganizationModel({
+      systems: {
+        'multi.sys': { id: 'multi.sys', order: 50000, label: 'Multi Sys', lifecycle: 'active', path: '/multi-sys' }
+      },
+      roles: {
+        'multi.role': { id: 'multi.role', order: 50000, title: 'Multi Role' }
+      },
+      actions: {
+        'multi.action': {
+          id: 'multi.action',
+          order: 50000,
+          label: 'Multi Action',
+          scope: 'global',
+          resourceId: 'multi-workflow'
+        }
+      }
+    })
+
+    expect(Object.keys(model.systems)).toHaveLength(baseSystems + 1)
+    expect(model.systems['multi.sys']).toBeDefined()
+
+    expect(Object.keys(model.roles)).toHaveLength(baseRoles + 1)
+    expect(model.roles['multi.role']).toBeDefined()
+
+    expect(Object.keys(model.actions)).toHaveLength(baseActions + 1)
+    expect(model.actions['multi.action']).toBeDefined()
+
+    expect(model.customers).toEqual(baseCustomers)
+    expect(model.goals).toEqual(baseGoals)
+  })
+
+  it('override sets top-level array field on entry to single-element array replacing the original', () => {
+    // The `invocations` field on an action entry is a top-level array.
+    // deepMerge sees Array.isArray(existing) and returns override directly.
+    const replacementInvocations = [{ kind: 'slash-command' as const, command: '/custom-source' }]
+
+    const override: DeepPartial<OrganizationModel> = {
+      actions: {
+        'lead-gen.company.source': {
+          id: 'lead-gen.company.source',
+          order: DEFAULT_ORGANIZATION_MODEL.actions['lead-gen.company.source']!.order,
+          label: 'Source companies',
+          invocations: replacementInvocations
+        }
+      }
+    }
+
+    const resolved = resolveOrganizationModel(override)
+    const entry = resolved.actions['lead-gen.company.source']!
+
+    expect(entry.invocations).toHaveLength(1)
+    expect(entry.invocations).toEqual(replacementInvocations)
+  })
+})

package/src/organization-model/__tests__/foundation.test.ts

@@ -2,56 +2,32 @@ import { describe, expect, it } from 'vitest'
 import { createFoundationOrganizationModel } from '../foundation'
 
 describe('createFoundationOrganizationModel', () => {
-  it('builds the foundation model from a branding-only override', () => {
+  it('builds the foundation model from derived sidebar navigation', () => {
     const result = createFoundationOrganizationModel({
       branding: { organizationName: 'Acme', productName: 'Acme OS', shortName: 'Acme' }
     })
 
     expect(result.canonical.branding.organizationName).toBe('Acme')
     expect(result.homeLabel).toBe('Dashboard')
-    expect(result.model.navigation.defaultSurfaceId).toBe('operations')
+    expect(result.model.navigation.defaultSurfaceId).toBe('dashboard')
 
     const surfaces = result.model.navigation.surfaces
-    expect(surfaces.find((s) => s.id === 'crm')).toBeDefined()
-    expect(surfaces.find((s) => s.id === 'lead-gen')).toBeDefined()
+    expect(surfaces.find((s) => s.id === 'dashboard')).toMatchObject({ path: '/', surfaceType: 'dashboard' })
+    expect(surfaces.find((s) => s.id === 'sales')).toBeDefined()
+    expect(surfaces.find((s) => s.id === 'clients')).toMatchObject({ path: '/clients' })
     expect(surfaces.find((s) => s.id === 'projects')).toBeDefined()
-    expect(surfaces.find((s) => s.id === 'operations')).toBeDefined()
-    expect(surfaces.find((s) => s.id === 'settings')).toBeDefined()
+    expect(surfaces.find((s) => s.id === 'operations-overview')).toBeDefined()
+    expect(surfaces.find((s) => s.id === 'settings-account')).toBeDefined()
 
-    expect(result.quickAccessSurfaceIds).toContain('operations')
+    expect(result.quickAccessSurfaceIds).toContain('sales')
+    expect(result.quickAccessSurfaceIds).toContain('clients')
     expect(result.quickAccessSurfaceIds).toContain('projects')
-    expect(result.quickAccessSurfaceIds).toContain('lead-gen')
-    expect(result.quickAccessSurfaceIds).toContain('crm')
+    expect(result.quickAccessSurfaceIds).toContain('operations-overview')
   })
 
-  it('passes deeper overrides through to the canonical model', () => {
-    const result = createFoundationOrganizationModel({
-      branding: { organizationName: 'Acme', productName: 'Acme OS', shortName: 'Acme' },
-      sales: {
-        pipelines: [
-          {
-            id: 'custom-pipeline',
-            label: 'Custom Pipeline',
-            description: 'A custom pipeline',
-            entityId: 'crm.deal',
-            stages: [
-              {
-                id: 'stage-1',
-                label: 'Stage 1',
-                color: 'blue',
-                order: 0,
-                semanticClass: 'open' as const,
-                surfaceIds: ['crm.pipeline'],
-                resourceIds: []
-              }
-            ]
-          }
-        ]
-      }
-    })
-
-    expect(result.canonical.sales.pipelines).toHaveLength(1)
-    expect(result.canonical.sales.pipelines[0]?.id).toBe('custom-pipeline')
+  it.skip('passes deeper overrides through to the canonical model (deferred - Phase 4: sales domain removed)', () => {
+    // Previously tested: result.canonical.sales.pipelines.
+    // Re-enable with a content-node based pipeline override test if needed.
   })
 
   it('exposes a working getOrganizationSurface lookup', () => {
@@ -59,47 +35,43 @@ describe('createFoundationOrganizationModel', () => {
       branding: { organizationName: 'Acme', productName: 'Acme OS', shortName: 'Acme' }
     })
 
-    const crmSurface = result.getOrganizationSurface('crm')
-    expect(crmSurface).toBeDefined()
-    expect(crmSurface?.id).toBe('crm')
-    expect(crmSurface?.icon).toBe('feature.crm')
-
-    expect(result.getOrganizationSurface('nonexistent')).toBeUndefined()
-  })
+    const clientsSurface = result.getOrganizationSurface('clients')
+    expect(clientsSurface).toBeDefined()
+    expect(clientsSurface?.id).toBe('clients')
+    expect(clientsSurface?.path).toBe('/clients')
 
-  it('throws when a required core surface is missing', () => {
-    const override = {
-      features: [
-        {
-          id: 'crm',
-          label: 'CRM',
-          description: 'CRM workspace',
-          enabled: true,
-          color: 'blue',
-          entityIds: [],
-          surfaceIds: ['custom.home'],
-          resourceIds: [],
-          capabilityIds: []
-        }
-      ],
+    expect(result.getOrganizationSurface('nonexistent')).toBeUndefined()
+  })
+
+  it('does not require hardcoded system-backed foundation surfaces', () => {
+    const result = createFoundationOrganizationModel({
       navigation: {
-        defaultSurfaceId: 'custom.home',
-        surfaces: [
-          {
-            id: 'custom.home',
-            label: 'Home',
-            path: '/home',
-            surfaceType: 'page' as const,
-            featureIds: ['crm'],
-            entityIds: [],
-            resourceIds: [],
-            capabilityIds: []
-          }
-        ],
-        groups: [{ id: 'primary', label: 'Primary', placement: 'primary', surfaceIds: ['custom.home'] }]
+        sidebar: {
+          primary: {
+            dashboard: {
+              type: 'surface',
+              label: 'Home',
+              path: '/',
+              surfaceType: 'dashboard',
+              order: 10,
+              targets: { systems: ['dashboard'] }
+            },
+            custom: {
+              type: 'surface',
+              label: 'Custom',
+              path: '/custom',
+              surfaceType: 'page',
+              order: 20,
+              targets: { systems: [] }
+            }
+          },
+          bottom: {}
+        }
       }
-    }
+    })
 
-    expect(() => createFoundationOrganizationModel(override)).toThrow(/Missing organization surface/)
+    expect(result.model.navigation.defaultSurfaceId).toBe('dashboard')
+    expect(result.homeLabel).toBe('Home')
+    expect(result.getOrganizationSurface('custom')).toMatchObject({ label: 'Custom', path: '/custom' })
   })
 })

package/src/organization-model/__tests__/get-resources-for-system.test.ts

@@ -0,0 +1,144 @@
+/**
+ * Unit tests for getResourcesForSystem helper.
+ *
+ * Coverage:
+ * - Empty model (no resources)
+ * - Single leaf resource, exact match
+ * - includeDescendants: true returns descendants
+ * - Deep nesting (three levels)
+ * - Segment-boundary safety: 'sales' must NOT match 'salesforce.foo'
+ * - Root path with includeDescendants: false
+ * - Root path with includeDescendants: true
+ * - Mixed resources, only matching ones returned
+ */
+import { describe, it, expect } from 'vitest'
+import { getResourcesForSystem } from '../helpers'
+import type { OrganizationModel } from '../types'
+import type { ResourceEntry } from '../domains/resources'
+
+// ---------------------------------------------------------------------------
+// Minimal fixture builder
+// ---------------------------------------------------------------------------
+
+function makeModel(resources: Record<string, ResourceEntry>): OrganizationModel {
+  return {
+    systems: {},
+    resources,
+    roles: {},
+    goals: {},
+    knowledge: {},
+    actions: {},
+    entities: {},
+    policies: {},
+    navigation: { sidebar: { primary: {}, bottom: {} } }
+  } as unknown as OrganizationModel
+}
+
+function makeWorkflow(id: string, systemPath: string): ResourceEntry {
+  return {
+    id,
+    order: 10,
+    kind: 'workflow',
+    systemPath,
+    status: 'active'
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('getResourcesForSystem', () => {
+  it('returns empty array when model has no resources', () => {
+    const model = makeModel({})
+    expect(getResourcesForSystem(model, 'sales')).toEqual([])
+  })
+
+  it('returns empty array when no resources match the path', () => {
+    const model = makeModel({
+      'wf-a': makeWorkflow('wf-a', 'marketing')
+    })
+    expect(getResourcesForSystem(model, 'sales')).toEqual([])
+  })
+
+  it('returns a single resource with exact match', () => {
+    const r = makeWorkflow('wf-a', 'sales')
+    const model = makeModel({ 'wf-a': r })
+    const result = getResourcesForSystem(model, 'sales')
+    expect(result).toHaveLength(1)
+    expect(result[0].id).toBe('wf-a')
+  })
+
+  it('does NOT return descendants when includeDescendants is false (default)', () => {
+    const model = makeModel({
+      'wf-a': makeWorkflow('wf-a', 'sales'),
+      'wf-b': makeWorkflow('wf-b', 'sales.crm'),
+      'wf-c': makeWorkflow('wf-c', 'sales.lead-gen')
+    })
+    const result = getResourcesForSystem(model, 'sales')
+    expect(result).toHaveLength(1)
+    expect(result[0].id).toBe('wf-a')
+  })
+
+  it('returns exact match AND descendants when includeDescendants is true', () => {
+    const model = makeModel({
+      'wf-a': makeWorkflow('wf-a', 'sales'),
+      'wf-b': makeWorkflow('wf-b', 'sales.crm'),
+      'wf-c': makeWorkflow('wf-c', 'sales.lead-gen'),
+      'wf-d': makeWorkflow('wf-d', 'marketing')
+    })
+    const result = getResourcesForSystem(model, 'sales', { includeDescendants: true })
+    const ids = result.map((r) => r.id).sort()
+    expect(ids).toEqual(['wf-a', 'wf-b', 'wf-c'])
+  })
+
+  it('matches three-level deep descendants', () => {
+    const model = makeModel({
+      'wf-a': makeWorkflow('wf-a', 'sales.crm.dispositions'),
+      'wf-b': makeWorkflow('wf-b', 'sales.crm'),
+      'wf-c': makeWorkflow('wf-c', 'sales')
+    })
+    const result = getResourcesForSystem(model, 'sales', { includeDescendants: true })
+    expect(result).toHaveLength(3)
+  })
+
+  it('segment-boundary: "sales" does NOT match "salesforce.foo"', () => {
+    const model = makeModel({
+      'wf-a': makeWorkflow('wf-a', 'salesforce.foo'),
+      'wf-b': makeWorkflow('wf-b', 'salesforce'),
+      'wf-c': makeWorkflow('wf-c', 'sales')
+    })
+    const result = getResourcesForSystem(model, 'sales', { includeDescendants: true })
+    // Only exact 'sales' match — 'salesforce' and 'salesforce.foo' must NOT appear
+    expect(result).toHaveLength(1)
+    expect(result[0].id).toBe('wf-c')
+  })
+
+  it('segment-boundary: "sys" does NOT match "sys2.foo" or "system.bar"', () => {
+    const model = makeModel({
+      'wf-a': makeWorkflow('wf-a', 'sys'),
+      'wf-b': makeWorkflow('wf-b', 'sys.platform'),
+      'wf-c': makeWorkflow('wf-c', 'sys2.foo'),
+      'wf-d': makeWorkflow('wf-d', 'system.bar')
+    })
+    const result = getResourcesForSystem(model, 'sys', { includeDescendants: true })
+    const ids = result.map((r) => r.id).sort()
+    expect(ids).toEqual(['wf-a', 'wf-b'])
+  })
+
+  it('root path with includeDescendants false returns only exact root resources', () => {
+    const model = makeModel({
+      'wf-a': makeWorkflow('wf-a', 'sys'),
+      'wf-b': makeWorkflow('wf-b', 'sys.platform'),
+      'wf-c': makeWorkflow('wf-c', 'sys.diagnostic')
+    })
+    const result = getResourcesForSystem(model, 'sys')
+    expect(result).toHaveLength(1)
+    expect(result[0].id).toBe('wf-a')
+  })
+
+  it('handles undefined resources gracefully via nullish coalescing', () => {
+    const model = { systems: {}, resources: undefined } as unknown as OrganizationModel
+    expect(getResourcesForSystem(model, 'sales')).toEqual([])
+  })
+})