@elevasis/core 0.1.0 → 0.2.0

package/src/reference/glossary.md

@@ -0,0 +1,88 @@
+---
+title: Glossary
+description: Terminology disambiguation for Organization OS concepts used in the template scaffold, foundations, and published packages.
+---
+
+# Glossary
+
+For canonical (internal) definitions, see the Organization OS glossary in the monorepo architecture docs.
+
+This condensed version covers every ambiguity-prone term a template consumer or agent is likely to encounter. Alphabetical within each section.
+
+---
+
+## Terms
+
+**accessFeatureKey** -- the `OrganizationModelFeatureKey` a `FeatureModule` declares so the provider knows which org-level gate to check. Required field on every `FeatureModule`. Distinct from the nav-item `featureKey` (see below). Shell keys like `crm` and `lead-gen` map to grouped org-model keys (`acquisition`) via `FEATURE_KEY_ALIASES` -- this aliasing is automatic; callers do not need to translate manually.
+
+**AdminGuard** -- route-level admin wrapper from `@elevasis/ui/features/auth`. Wraps routes restricted to admin members. Must nest inside `ProtectedRoute`. Does not replace `requiresAdmin` on nav entries -- use both when both route access and nav visibility need admin enforcement.
+
+**Contract** -- the publishable I/O boundary: Zod schemas in `foundations/types/index.ts` for workflow inputs/outputs, or the `FeatureModule` TypeScript shape for shell features. Distinct from "manifest": a contract is the structural definition; a manifest is a specific feature instance conforming to that shape.
+
+**DeploymentSpec** -- the complete resource collection for one organization (`workflows`, `agents`, `triggers`, `integrations`, `relationships`, `externalResources`, `humanCheckpoints`). Defined in `@repo/core`. The `operations/src/index.ts` file in each external project exports one `DeploymentSpec`.
+
+**Domain** -- a semantic business area in `OrganizationModel.domains`. Four defaults: `crm`, `lead-gen`, `delivery`, `operations`. Domains group entity IDs, surface IDs, resource IDs, and capability IDs into a coherent business area. Semantic, not navigational -- describes what business area a thing belongs to, not which access key gates it. Distinct from "feature": a domain describes business meaning; a feature key describes access and enablement.
+
+**FEATURE_KEY_ALIASES** -- the alias map in `@elevasis/ui` that bridges shell feature-module keys to org-model grouped keys: `crm -> acquisition`, `lead-gen -> acquisition`, `projects -> delivery`. Used internally by `createFeatureAccessHook` so `isFeatureEnabled('crm')` resolves correctly against `MembershipFeatureConfig.features.acquisition`.
+
+**FoundationLegacyFeatureKey** -- template-local union for feature keys defined in `foundations/config/organization-model.ts`. Distinct from the published `OrganizationModelFeatureKey` (seven-key union from `@elevasis/core`). Extension point for template-specific feature identity without modifying the published core union. `FoundationFeatureKey` combines both (`OrganizationModelFeatureKey | FoundationLegacyFeatureKey`). `FEATURE_KEY_ALIASES` maps between shell keys and org-model grouped keys at runtime.
+
+**Feature** -- an overloaded term. Always qualify which layer is in scope:
+
+- **Platform capability** -- a product area (Execution Engine, Workflows, Agents, etc.). Not one-to-one with shell features.
+- **Shell FeatureModule** -- a manifest-backed UI feature registered with `ElevasisFeaturesProvider`. Seven manifest-backed: `lead-gen`, `crm`, `delivery`, `operations`, `monitoring`, `settings`, `seo`. Two utility (no manifest): `auth`, `dashboard`.
+- **Organization-model feature key** (`OrganizationModelFeatureKey`) -- grouped access key. Seven values: `acquisition`, `delivery`, `operations`, `monitoring`, `settings`, `seo`, `calibration`. Controls org-level gating and membership overrides.
+
+**featureKey** (nav-item) -- optional field on `FeatureNavEntry` and `FeatureNavLink` that gates a specific nav item's visibility independently of the module's `accessFeatureKey`. Resolved through `FEATURE_KEY_ALIASES`. May be more specific than the module's access key when a nested link needs a narrower gate.
+
+**FeatureGuard** -- route-level feature gate from `@elevasis/ui/features/auth`. Blocks access to a route when the resolved org model has the relevant feature key disabled. Must nest inside `ProtectedRoute`. Distinct from `AdminGuard` (admin membership) and `ProtectedRoute` (authentication).
+
+**FeatureModule** -- the manifest contract each shell feature provides to `ElevasisFeaturesProvider`. Defined in `@repo/ui`, NOT `@repo/core`. Fields: `key`, `accessFeatureKey` (required), `domainIds`, `capabilityIds`, `navEntry`, `sidebar`, `subshellRoutes`, `organizationGraph` (Operations-only). Template consumers build a local manifest array and pass it to `ElevasisFeaturesProvider` in `__root.tsx`.
+
+**Foundations** -- the adapter layer in `foundations/` (two modules: `config/organization-model.ts` and `types/index.ts`). Source package with no build step. Depends only on `@elevasis/core` (npm) and `zod`. Never import `@repo/core` from foundations -- that would break standalone deployment.
+
+**Manifest** -- a `FeatureModule` instance that declares what one shell feature contributes at runtime (nav, sidebar, subshell routes, access key, semantic references). The provider registers an array of manifests at startup and validates them against the resolved org model.
+
+**MembershipFeatureConfig** -- per-member-per-org feature overrides stored in `org_memberships.config`. Six keys: `operations`, `monitoring`, `acquisition`, `delivery`, `calibration`, `seo`. Note: `settings` is absent -- see **Settings asymmetry** below.
+
+**OrganizationModel** -- the top-level semantic contract for an organization. Published from `@elevasis/core/organization-model`. In the template, authored in `foundations/config/organization-model.ts` and exported as `canonicalOrganizationModel` (passed to `ElevasisFeaturesProvider`) and `organizationModel` (enriched shape for app-local use).
+
+**OrganizationModelFeatureKey** -- seven values: `acquisition`, `delivery`, `operations`, `monitoring`, `settings`, `seo`, `calibration`. These appear in `OrganizationModel.features.enabled` and as `accessFeatureKey` on `FeatureModule` instances. `MembershipFeatureConfig` overrides six of them per member (no `settings` slot -- see **Settings asymmetry**).
+
+**Provider / ElevasisFeaturesProvider** -- the runtime that registers manifests, resolves feature access against the org model, dispatches subshell routing via `FeatureShell`, and exposes resolved state through `useElevasisFeatures()`. Mounted in `__root.tsx`. Accepts `features`, optional `organizationModel`, and optional `appShellOverrides`.
+
+**Resolved types (ResolvedFeatureModule, ResolvedShellNavItem)** -- provider output. `ResolvedFeatureModule` extends `FeatureModule` with `access` (enabled state) and `semantics` (merged domain, capability, and surface IDs). `ResolvedShellNavItem` extends `FeatureNavEntry` with `placement`, `source`, and `accessFeatureKey`. Both from `@elevasis/ui`.
+
+**Resource** -- an entry in `OrganizationModel.resourceMappings` linking a deployable automation resource into the semantic model. At the registry layer, resources are `WorkflowDefinition` or `AgentDefinition` instances in a `DeploymentSpec`.
+
+**Settings asymmetry** -- `settings` is a valid `OrganizationModelFeatureKey` (org-level, present in `OrganizationModel.features.enabled`). It is absent from `MembershipFeatureConfig` (six keys, no `settings`). The org can disable settings entirely, but per-member disabling is not supported. Settings visibility for individual members is controlled via `requiresAdmin` on the nav entry and `AdminGuard` on routes.
+
+**Subshell / Sidebar** -- the feature-scoped UI region rendered when the current route matches a manifest's `subshellRoutes`. Each `FeatureModule.sidebar` is a `ComponentType`. Consumers customize by composing the feature's published sidebar primitives (`CrmSidebar`, `CrmSidebarMiddle`, etc.) and assigning their component to `manifest.sidebar`.
+
+**Surface** -- a navigable view in `OrganizationModel.navigation.surfaces`. Identified by a dotted `id` (e.g., `crm.pipeline`). Has `path`, `surfaceType`, optional `featureKey` gate, and cross-reference arrays. Distinct from "page": a surface is the org-model declaration; a page is the React component rendered at the route.
+
+**Topology** -- resource relationships (`triggers`, `uses`, `approval`) declared in `DeploymentSpec.relationships` and `HumanCheckpointDefinition.routesTo`. Used for Command View graph edges.
+
+---
+
+## Package-Boundary Cheat Sheet
+
+**`@elevasis/core`** (published npm)
+
+- `OrganizationModel`, `OrganizationModelFeatureKey`, `OrganizationModelSurface`, `OrganizationModelResourceMapping`
+- `resolveOrganizationModel`, `defineOrganizationModel`, `DEFAULT_ORGANIZATION_MODEL`
+- `MembershipFeatureConfig`
+
+**`@elevasis/ui`** (published npm)
+
+- `FeatureModule`, `FeatureNavEntry`, `FeatureNavLink`
+- `ResolvedFeatureModule`, `ResolvedShellNavItem`
+- `FeatureGuard`, `AdminGuard`, `ProtectedRoute`
+- `ElevasisFeaturesProvider`, `ElevasisCoreProvider`, `useElevasisFeatures`
+- `FEATURE_KEY_ALIASES`, `createFeatureAccessHook`
+
+**`foundations/`** (local source package -- not published)
+
+- `canonicalOrganizationModel` -- passed to `ElevasisFeaturesProvider`
+- `organizationModel` -- enriched shape for app-local code
+- Workflow I/O schemas (`types/index.ts`)

package/src/server.ts

@@ -202,9 +202,8 @@ export { createLLMCallTool, type LLMCallToolConfig } from './execution/engine/to
 // Workflow step helper (uses server-only adapters)
 export { llmCall, type LLMCallOptions } from './execution/engine/workflow/helpers/server'
 
-// Resource invocation tool factory (uses runtime service registry)
-export { createResourceInvocationTool } from './execution/engine/tools/platform/resource-invocation'
-export type { ResourceDefinition } from './execution/engine/tools/platform/resource-invocation'
+// Retained server-side resource invocation service types live under @repo/core/execution.
+// Deployed SDK workers use platform.call() -> dispatcher for nested execution.
 
 // Resilience utilities (timeout, circuit breaker, infrastructure errors)
 export {

package/src/execution/engine/tools/platform/resource-invocation/__tests__/edge-cases.test.ts

@@ -1,507 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { z } from 'zod'
-import { ResourceInvocationService, createResourceInvocationService } from '../resource-invocation-service'
-import type { ResourceRegistry } from '../../../../../../platform/registry/resource-registry'
-import type { WorkflowDefinition } from '../../../../workflow/types'
-import type { AgentDefinition } from '../../../../agent/core/types'
-import type { ExecuteResourceCallback } from '../types'
-import { createMockExecutionContext } from '../../../../test-utils/mocks'
-
-describe('ResourceInvocationService Edge Cases', () => {
-  let mockRegistry: ResourceRegistry
-  let mockExecuteResource: ReturnType<typeof vi.fn>
-  let service: ResourceInvocationService
-
-  const mockWorkflowDefinition: WorkflowDefinition = {
-    config: {
-      resourceId: 'test-workflow',
-      name: 'Test Workflow',
-      description: 'Test workflow for edge cases',
-      version: '1.0.0',
-      type: 'workflow',
-      status: 'dev'
-    },
-    contract: {
-      inputSchema: z.object({
-        value: z.string()
-      }),
-      outputSchema: z.object({
-        result: z.string()
-      })
-    },
-    entryPoint: 'start',
-    steps: {}
-  }
-
-  const mockAgentDefinition: AgentDefinition = {
-    config: {
-      resourceId: 'test-agent',
-      name: 'Test Agent',
-      description: 'Test agent for edge cases',
-      version: '1.0.0',
-      type: 'agent',
-      status: 'dev'
-    },
-    contract: {
-      inputSchema: z.object({
-        query: z.string()
-      }),
-      outputSchema: z.object({
-        answer: z.string()
-      })
-    },
-    modelConfig: {
-      provider: 'openai',
-      model: 'gpt-4o',
-      temperature: 0.7
-    },
-    systemPrompt: 'You are a test agent',
-    tools: []
-  }
-
-  beforeEach(() => {
-    mockRegistry = {
-      getResourceDefinition: vi.fn(),
-      getRelationships: vi.fn().mockReturnValue(undefined)
-    } as unknown as ResourceRegistry
-
-    mockExecuteResource = vi.fn()
-
-    service = new ResourceInvocationService(mockRegistry, mockExecuteResource)
-  })
-
-  describe('concurrent invocations', () => {
-    it('handles concurrent invocations without state mixing', async () => {
-      // Setup: All invocations use the same resource definition
-      vi.mocked(mockRegistry.getResourceDefinition).mockReturnValue(mockWorkflowDefinition)
-
-      // Mock executor that returns different results based on input
-      mockExecuteResource.mockImplementation(async (request) => {
-        // Simulate async delay
-        await new Promise(resolve => setTimeout(resolve, 10))
-
-        return {
-          success: true,
-          output: { result: `processed-${request.input.value}` },
-          executionId: `exec-${request.input.value}`,
-          resourceType: 'workflow'
-        }
-      })
-
-      const mockContext = createMockExecutionContext({
-        organizationId: 'org-123',
-        organizationName: 'test-org'
-      })
-
-      // Launch 3 parallel calls with different inputs
-      const results = await Promise.all([
-        service.executeSync('test-workflow', { value: 'input-1' }, 'test-org', mockContext),
-        service.executeSync('test-workflow', { value: 'input-2' }, 'test-org', mockContext),
-        service.executeSync('test-workflow', { value: 'input-3' }, 'test-org', mockContext)
-      ])
-
-      // Verify each returns its own result without interference
-      expect(results[0].success).toBe(true)
-      expect(results[0].output).toEqual({ result: 'processed-input-1' })
-      expect(results[0].executionId).toBe('exec-input-1')
-
-      expect(results[1].success).toBe(true)
-      expect(results[1].output).toEqual({ result: 'processed-input-2' })
-      expect(results[1].executionId).toBe('exec-input-2')
-
-      expect(results[2].success).toBe(true)
-      expect(results[2].output).toEqual({ result: 'processed-input-3' })
-      expect(results[2].executionId).toBe('exec-input-3')
-
-      // Verify all three calls were made
-      expect(mockExecuteResource).toHaveBeenCalledTimes(3)
-    })
-  })
-
-  describe('empty input validation', () => {
-    it('handles empty object input for resources with z.object({})', async () => {
-      // Create resource with z.object({}) schema (accepts any object)
-      const emptySchemaWorkflow: WorkflowDefinition = {
-        ...mockWorkflowDefinition,
-        contract: {
-          inputSchema: z.object({}),
-          outputSchema: z.object({ status: z.string() })
-        }
-      }
-
-      vi.mocked(mockRegistry.getResourceDefinition).mockReturnValue(emptySchemaWorkflow)
-
-      mockExecuteResource.mockResolvedValue({
-        success: true,
-        output: { status: 'completed' },
-        executionId: 'exec-empty',
-        resourceType: 'workflow'
-      })
-
-      const mockContext = createMockExecutionContext({
-        organizationName: 'test-org'
-      })
-
-      // Verify empty {} input is valid
-      const result = await service.executeSync(
-        'empty-schema-workflow',
-        {},
-        'test-org',
-        mockContext
-      )
-
-      expect(result.success).toBe(true)
-      expect(result.output).toEqual({ status: 'completed' })
-      expect(mockExecuteResource).toHaveBeenCalledWith(
-        expect.objectContaining({
-          input: {}
-        }),
-        mockContext
-      )
-    })
-  })
-
-  describe('execution depth limits', () => {
-    it('allows execution at depth 4 (one below limit)', async () => {
-      vi.mocked(mockRegistry.getResourceDefinition).mockReturnValue(mockWorkflowDefinition)
-
-      mockExecuteResource.mockResolvedValue({
-        success: true,
-        output: { result: 'depth-4-success' },
-        executionId: 'exec-depth-4',
-        resourceType: 'workflow'
-      })
-
-      // Context with executionDepth: 4
-      const contextDepth4 = createMockExecutionContext({
-        organizationName: 'test-org',
-        executionDepth: 4
-      })
-
-      const result = await service.executeSync(
-        'test-workflow',
-        { value: 'test' },
-        'test-org',
-        contextDepth4
-      )
-
-      // Should succeed (limit is 5)
-      expect(result.success).toBe(true)
-      expect(result.output).toEqual({ result: 'depth-4-success' })
-      expect(mockExecuteResource).toHaveBeenCalledWith(
-        expect.anything(),
-        contextDepth4
-      )
-    })
-
-    it('blocks execution at depth 5 (at limit)', async () => {
-      vi.mocked(mockRegistry.getResourceDefinition).mockReturnValue(mockWorkflowDefinition)
-
-      // Mock executor to reject at depth 5
-      mockExecuteResource.mockResolvedValue({
-        success: false,
-        output: null,
-        executionId: '',
-        resourceType: 'workflow',
-        error: 'Maximum execution depth exceeded'
-      })
-
-      // Context with executionDepth: 5
-      const contextDepth5 = createMockExecutionContext({
-        organizationName: 'test-org',
-        executionDepth: 5
-      })
-
-      const result = await service.executeSync(
-        'test-workflow',
-        { value: 'test' },
-        'test-org',
-        contextDepth5
-      )
-
-      // Should fail with depth exceeded error
-      expect(result.success).toBe(false)
-      expect(result.error).toContain('Maximum execution depth exceeded')
-    })
-  })
-
-  describe('null vs undefined output semantics', () => {
-    it('distinguishes null output (fire-and-forget) from undefined', async () => {
-      // Resource with outputSchema: null (fire-and-forget pattern)
-      const fireAndForgetWorkflow: WorkflowDefinition = {
-        ...mockWorkflowDefinition,
-        contract: {
-          inputSchema: z.object({ data: z.string() }),
-          outputSchema: null
-        }
-      }
-
-      vi.mocked(mockRegistry.getResourceDefinition).mockReturnValue(fireAndForgetWorkflow)
-
-      // Resource should return null (not undefined)
-      mockExecuteResource.mockResolvedValue({
-        success: true,
-        output: null,
-        executionId: 'exec-null',
-        resourceType: 'workflow'
-      })
-
-      const mockContext = createMockExecutionContext({
-        organizationName: 'test-org'
-      })
-
-      const result = await service.executeSync(
-        'fire-and-forget',
-        { data: 'test' },
-        'test-org',
-        mockContext
-      )
-
-      // Verify output is explicitly null, not undefined
-      expect(result.success).toBe(true)
-      expect(result.output).toBeNull()
-      expect(result.output).not.toBeUndefined()
-    })
-  })
-
-  describe('complex nested schema validation', () => {
-    it('validates deeply nested input schemas', async () => {
-      // Resource with deeply nested schema
-      const nestedSchemaWorkflow: WorkflowDefinition = {
-        ...mockWorkflowDefinition,
-        contract: {
-          inputSchema: z.object({
-            nested: z.object({
-              deep: z.object({
-                value: z.string().min(1)
-              })
-            })
-          }),
-          outputSchema: z.object({ result: z.string() })
-        }
-      }
-
-      vi.mocked(mockRegistry.getResourceDefinition).mockReturnValue(nestedSchemaWorkflow)
-
-      mockExecuteResource.mockResolvedValue({
-        success: true,
-        output: { result: 'nested-success' },
-        executionId: 'exec-nested',
-        resourceType: 'workflow'
-      })
-
-      const mockContext = createMockExecutionContext({
-        organizationName: 'test-org'
-      })
-
-      // Test valid deeply nested input
-      const validResult = await service.executeSync(
-        'nested-schema-workflow',
-        {
-          nested: {
-            deep: {
-              value: 'valid-value'
-            }
-          }
-        },
-        'test-org',
-        mockContext
-      )
-
-      expect(validResult.success).toBe(true)
-      expect(validResult.output).toEqual({ result: 'nested-success' })
-
-      // Test invalid deeply nested input (empty string violates min(1))
-      const invalidResult = await service.executeSync(
-        'nested-schema-workflow',
-        {
-          nested: {
-            deep: {
-              value: '' // Violates min(1)
-            }
-          }
-        },
-        'test-org',
-        mockContext
-      )
-
-      expect(invalidResult.success).toBe(false)
-      expect(invalidResult.error).toContain('Input validation failed')
-
-      // Test missing nested field
-      const missingFieldResult = await service.executeSync(
-        'nested-schema-workflow',
-        {
-          nested: {
-            // Missing 'deep' field
-          }
-        },
-        'test-org',
-        mockContext
-      )
-
-      expect(missingFieldResult.success).toBe(false)
-      expect(missingFieldResult.error).toContain('Input validation failed')
-    })
-  })
-
-  describe('error preservation through chain', () => {
-    it('preserves error context through invocation chain', async () => {
-      vi.mocked(mockRegistry.getResourceDefinition).mockReturnValue(mockAgentDefinition)
-
-      // Executor returns error with specific message
-      const specificErrorMessage = 'Agent execution failed: Model API rate limit exceeded (429)'
-      mockExecuteResource.mockResolvedValue({
-        success: false,
-        output: null,
-        executionId: 'exec-error',
-        resourceType: 'agent',
-        error: specificErrorMessage
-      })
-
-      const mockContext = createMockExecutionContext({
-        organizationName: 'test-org'
-      })
-
-      const result = await service.executeSync(
-        'test-agent',
-        { query: 'test query' },
-        'test-org',
-        mockContext
-      )
-
-      // Verify error message preserved in result
-      expect(result.success).toBe(false)
-      expect(result.error).toBe(specificErrorMessage)
-      expect(result.error).toContain('Model API rate limit exceeded')
-      expect(result.error).toContain('429')
-    })
-  })
-
-  describe('self-invocation prevention', () => {
-    it('handles invocation of same resourceId (no infinite loop)', async () => {
-      vi.mocked(mockRegistry.getResourceDefinition).mockReturnValue(mockAgentDefinition)
-
-      // Mock executor that checks for recursion depth
-      let invocationCount = 0
-      mockExecuteResource.mockImplementation(async (request, context) => {
-        invocationCount++
-
-        // Simulate depth limit enforcement in coordinator
-        if (context.executionDepth >= 5) {
-          return {
-            success: false,
-            output: null,
-            executionId: '',
-            resourceType: 'agent',
-            error: 'Maximum execution depth exceeded'
-          }
-        }
-
-        return {
-          success: true,
-          output: { answer: `invocation-${invocationCount}` },
-          executionId: `exec-${invocationCount}`,
-          resourceType: 'agent'
-        }
-      })
-
-      // Parent agent trying to invoke itself
-      const parentContext = createMockExecutionContext({
-        organizationName: 'test-org',
-        resourceId: 'test-agent',
-        executionDepth: 5 // At depth limit
-      })
-
-      const result = await service.executeSync(
-        'test-agent', // Same as parent resourceId
-        { query: 'recursive query' },
-        'test-org',
-        parentContext
-      )
-
-      // Depth limit should prevent infinite recursion
-      expect(result.success).toBe(false)
-      expect(result.error).toContain('Maximum execution depth exceeded')
-      expect(invocationCount).toBe(1) // Only one attempt made
-    })
-  })
-
-  describe('multiple organizations isolation', () => {
-    it('prevents cross-organization resource access', async () => {
-      // Setup: Registry returns resource for org-a, nothing for org-b
-      vi.mocked(mockRegistry.getResourceDefinition).mockImplementation((orgName, resourceId) => {
-        if (orgName === 'org-a' && resourceId === 'private-workflow') {
-          return mockWorkflowDefinition
-        }
-        return null
-      })
-
-      const contextOrgA = createMockExecutionContext({
-        organizationId: 'org-a-id',
-        organizationName: 'org-a'
-      })
-
-      const contextOrgB = createMockExecutionContext({
-        organizationId: 'org-b-id',
-        organizationName: 'org-b'
-      })
-
-      mockExecuteResource.mockResolvedValue({
-        success: true,
-        output: { result: 'success' },
-        executionId: 'exec-org-a',
-        resourceType: 'workflow'
-      })
-
-      // org-a should succeed
-      const resultOrgA = await service.executeSync(
-        'private-workflow',
-        { value: 'test' },
-        'org-a',
-        contextOrgA
-      )
-
-      expect(resultOrgA.success).toBe(true)
-      expect(mockRegistry.getResourceDefinition).toHaveBeenCalledWith('org-a', 'private-workflow')
-
-      // org-b should fail (resource not found)
-      const resultOrgB = await service.executeSync(
-        'private-workflow',
-        { value: 'test' },
-        'org-b',
-        contextOrgB
-      )
-
-      expect(resultOrgB.success).toBe(false)
-      expect(resultOrgB.error).toContain('Resource not found')
-      expect(mockRegistry.getResourceDefinition).toHaveBeenCalledWith('org-b', 'private-workflow')
-    })
-  })
-
-  describe('factory function edge cases', () => {
-    it('throws with null registry', () => {
-      expect(() => {
-        createResourceInvocationService(null as unknown as ResourceRegistry, mockExecuteResource)
-      }).toThrow('ResourceRegistry required')
-    })
-
-    it('throws with undefined registry', () => {
-      expect(() => {
-        createResourceInvocationService(undefined as unknown as ResourceRegistry, mockExecuteResource)
-      }).toThrow('ResourceRegistry required')
-    })
-
-    it('throws with null executeResource callback', () => {
-      expect(() => {
-        createResourceInvocationService(mockRegistry, null as unknown as ExecuteResourceCallback)
-      }).toThrow('executeResource callback required')
-    })
-
-    it('throws with undefined executeResource callback', () => {
-      expect(() => {
-        createResourceInvocationService(mockRegistry, undefined as unknown as ExecuteResourceCallback)
-      }).toThrow('executeResource callback required')
-    })
-  })
-})