@elevasis/core 0.18.0 → 0.20.0

package/src/execution/engine/tools/tool-maps.ts

@@ -258,6 +258,8 @@ import type {
   RecordListExecutionParams,
   UpdateCompanyStageParams,
   UpdateContactStageParams,
+  ListPendingCompanyIdsParams,
+  ListPendingContactIdsParams,
   UpsertSocialPostParams,
   UpsertSocialPostsResult,
   GetDealByIdParams,
@@ -725,6 +727,14 @@ export type ListToolMap = {
     params: Omit<UpdateContactStageParams, 'organizationId'>
     result: void
   }
+  listPendingCompanyIds: {
+    params: Omit<ListPendingCompanyIdsParams, 'organizationId'>
+    result: string[]
+  }
+  listPendingContactIds: {
+    params: Omit<ListPendingContactIdsParams, 'organizationId'>
+    result: string[]
+  }
 }
 
 // ---------------------------------------------------------------------------

package/src/execution/external/__tests__/api-schemas.test.ts

@@ -0,0 +1,127 @@
+import { describe, expect, it } from 'vitest'
+import { ExecuteAsyncEnvelopeSchema, GetExecutionsQuerySchema } from '../api-schemas'
+
+// ---------------------------------------------------------------------------
+// ExecuteAsyncEnvelopeSchema
+// ---------------------------------------------------------------------------
+
+describe('ExecuteAsyncEnvelopeSchema', () => {
+  it('accepts a minimal payload with only resourceId', () => {
+    const result = ExecuteAsyncEnvelopeSchema.safeParse({ resourceId: 'my-workflow' })
+    expect(result.success).toBe(true)
+  })
+
+  it('accepts resourceId with optional input passthrough', () => {
+    const result = ExecuteAsyncEnvelopeSchema.safeParse({
+      resourceId: 'my-workflow',
+      input: { foo: 'bar', nested: { count: 5 } }
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.resourceId).toBe('my-workflow')
+      expect(result.data.input).toEqual({ foo: 'bar', nested: { count: 5 } })
+    }
+  })
+
+  it('accepts any arbitrary input shape (unknown passthrough)', () => {
+    const result = ExecuteAsyncEnvelopeSchema.safeParse({
+      resourceId: 'some-resource',
+      input: [1, 2, 3]
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('accepts input as null (unknown type allows null)', () => {
+    const result = ExecuteAsyncEnvelopeSchema.safeParse({ resourceId: 'r', input: null })
+    expect(result.success).toBe(true)
+  })
+
+  it('accepts payload without input field (input is optional)', () => {
+    const result = ExecuteAsyncEnvelopeSchema.safeParse({ resourceId: 'r' })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.input).toBeUndefined()
+    }
+  })
+
+  it('rejects an empty resourceId (minLength 1)', () => {
+    expect(ExecuteAsyncEnvelopeSchema.safeParse({ resourceId: '' }).success).toBe(false)
+  })
+
+  it('rejects a missing resourceId', () => {
+    expect(ExecuteAsyncEnvelopeSchema.safeParse({}).success).toBe(false)
+    expect(ExecuteAsyncEnvelopeSchema.safeParse({ input: { x: 1 } }).success).toBe(false)
+  })
+
+  it('rejects resourceId as a non-string type', () => {
+    expect(ExecuteAsyncEnvelopeSchema.safeParse({ resourceId: 42 }).success).toBe(false)
+    expect(ExecuteAsyncEnvelopeSchema.safeParse({ resourceId: null }).success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// GetExecutionsQuerySchema
+// ---------------------------------------------------------------------------
+
+describe('GetExecutionsQuerySchema', () => {
+  it('accepts an empty query and applies default limit of 50', () => {
+    const result = GetExecutionsQuerySchema.safeParse({})
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.limit).toBe(50)
+    }
+  })
+
+  it('coerces limit from string "10" to number 10', () => {
+    const result = GetExecutionsQuerySchema.safeParse({ limit: '10' })
+    expect(result.success).toBe(true)
+    if (result.success) expect(result.data.limit).toBe(10)
+  })
+
+  it('coerces limit from string "100" to number 100 (upper boundary)', () => {
+    const result = GetExecutionsQuerySchema.safeParse({ limit: '100' })
+    expect(result.success).toBe(true)
+    if (result.success) expect(result.data.limit).toBe(100)
+  })
+
+  it('coerces limit from string "1" to number 1 (lower boundary)', () => {
+    const result = GetExecutionsQuerySchema.safeParse({ limit: '1' })
+    expect(result.success).toBe(true)
+    if (result.success) expect(result.data.limit).toBe(1)
+  })
+
+  it('rejects limit of 101 (above max 100)', () => {
+    expect(GetExecutionsQuerySchema.safeParse({ limit: '101' }).success).toBe(false)
+  })
+
+  it('rejects limit of 0 (below min 1)', () => {
+    expect(GetExecutionsQuerySchema.safeParse({ limit: '0' }).success).toBe(false)
+  })
+
+  it('rejects a negative limit', () => {
+    expect(GetExecutionsQuerySchema.safeParse({ limit: '-1' }).success).toBe(false)
+  })
+
+  it('rejects a non-numeric string for limit', () => {
+    expect(GetExecutionsQuerySchema.safeParse({ limit: 'abc' }).success).toBe(false)
+  })
+
+  it('accepts status as an optional string filter', () => {
+    const result = GetExecutionsQuerySchema.safeParse({ status: 'running' })
+    expect(result.success).toBe(true)
+    if (result.success) expect(result.data.status).toBe('running')
+  })
+
+  it('accepts status as undefined (optional field omitted)', () => {
+    const result = GetExecutionsQuerySchema.safeParse({})
+    expect(result.success).toBe(true)
+    if (result.success) expect(result.data.status).toBeUndefined()
+  })
+
+  it('note: GetExecutionsQuerySchema does not have an offset field', () => {
+    // The schema only defines limit and status -- no offset field exists.
+    // Passing offset is neither rejected nor coerced (schema is not strict).
+    const result = GetExecutionsQuerySchema.safeParse({ limit: '10', offset: '5' })
+    expect(result.success).toBe(true)
+  })
+})

package/src/integrations/oauth/__tests__/provider-registry.test.ts

@@ -38,12 +38,13 @@ describe('OAuth Provider Registry', () => {
   })
 
   describe('listProviders', () => {
-    it('should return all providers as array', () => {
-      const providers = listProviders()
-      expect(providers).toHaveLength(2)
-      expect(providers).toContainEqual(OAUTH_PROVIDERS['google-sheets'])
-      expect(providers).toContainEqual(OAUTH_PROVIDERS.dropbox)
-    })
+    it('should return all providers as array', () => {
+      const providers = listProviders()
+      expect(providers).toHaveLength(Object.keys(OAUTH_PROVIDERS).length)
+      expect(providers).toContainEqual(OAUTH_PROVIDERS['google-sheets'])
+      expect(providers).toContainEqual(OAUTH_PROVIDERS['google-calendar'])
+      expect(providers).toContainEqual(OAUTH_PROVIDERS.dropbox)
+    })
 
     it('should return array with correct provider structure', () => {
       const providers = listProviders()

package/src/integrations/oauth/provider-registry.ts

@@ -1,61 +1,74 @@
-import type { OAuthProviderConfig } from './types'
-
-/**
- * OAuth Provider Registry
- *
- * Add new integration = add config object here (no new code needed)
- *
- * Standard token exchange methods:
- * - basic-auth: client_id:client_secret in Authorization header
- * - form-encoded: credentials in URL-encoded body (Google)
- * - json-body: credentials in JSON body (most providers)
- *
- * Custom overrides for edge cases:
- * - customAuthFlow: Override authorization URL building
- * - customTokenExchange: Override token exchange logic
- */
-export const OAUTH_PROVIDERS: Record<string, OAuthProviderConfig> = {
-  'google-sheets': {
-    id: 'google-sheets',
-    name: 'Google Sheets',
-    authUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
-    tokenUrl: 'https://oauth2.googleapis.com/token',
-    authParams: {
-      access_type: 'offline', // Required for refresh token
-      prompt: 'consent' // Force consent to get refresh token on reconnect
-    },
-    tokenExchange: 'form-encoded',
-    scopes: ['https://www.googleapis.com/auth/spreadsheets']
-  },
-
-  dropbox: {
-    id: 'dropbox',
-    name: 'Dropbox',
-    authUrl: 'https://www.dropbox.com/oauth2/authorize',
-    tokenUrl: 'https://api.dropboxapi.com/oauth2/token',
-    authParams: {
-      token_access_type: 'offline' // Required for refresh token
-    },
-    tokenExchange: 'form-encoded',
-    scopes: ['files.content.write', 'files.content.read', 'files.metadata.write']
-  }
-}
-
-/**
- * Get provider config by ID
- * @throws Error if provider not found
- */
-export function getProviderConfig(providerId: string): OAuthProviderConfig {
-  const config = OAUTH_PROVIDERS[providerId]
-  if (!config) {
-    throw new Error(`Unknown OAuth provider: ${providerId}`)
-  }
-  return config
-}
-
-/**
- * List all available providers (for frontend)
- */
-export function listProviders(): OAuthProviderConfig[] {
-  return Object.values(OAUTH_PROVIDERS)
-}
+import type { OAuthProviderConfig } from './types'
+
+/**
+ * OAuth Provider Registry
+ *
+ * Add new integration = add config object here (no new code needed)
+ *
+ * Standard token exchange methods:
+ * - basic-auth: client_id:client_secret in Authorization header
+ * - form-encoded: credentials in URL-encoded body (Google)
+ * - json-body: credentials in JSON body (most providers)
+ *
+ * Custom overrides for edge cases:
+ * - customAuthFlow: Override authorization URL building
+ * - customTokenExchange: Override token exchange logic
+ */
+export const OAUTH_PROVIDERS: Record<string, OAuthProviderConfig> = {
+  'google-sheets': {
+    id: 'google-sheets',
+    name: 'Google Sheets',
+    authUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
+    tokenUrl: 'https://oauth2.googleapis.com/token',
+    authParams: {
+      access_type: 'offline', // Required for refresh token
+      prompt: 'consent' // Force consent to get refresh token on reconnect
+    },
+    tokenExchange: 'form-encoded',
+    scopes: ['https://www.googleapis.com/auth/spreadsheets']
+  },
+
+  'google-calendar': {
+    id: 'google-calendar',
+    name: 'Google Calendar',
+    authUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
+    tokenUrl: 'https://oauth2.googleapis.com/token',
+    authParams: {
+      access_type: 'offline', // Required for refresh token
+      prompt: 'consent' // Force consent to get refresh token on reconnect
+    },
+    tokenExchange: 'form-encoded',
+    scopes: ['https://www.googleapis.com/auth/calendar.readonly']
+  },
+
+  dropbox: {
+    id: 'dropbox',
+    name: 'Dropbox',
+    authUrl: 'https://www.dropbox.com/oauth2/authorize',
+    tokenUrl: 'https://api.dropboxapi.com/oauth2/token',
+    authParams: {
+      token_access_type: 'offline' // Required for refresh token
+    },
+    tokenExchange: 'form-encoded',
+    scopes: ['files.content.write', 'files.content.read', 'files.metadata.write']
+  }
+}
+
+/**
+ * Get provider config by ID
+ * @throws Error if provider not found
+ */
+export function getProviderConfig(providerId: string): OAuthProviderConfig {
+  const config = OAUTH_PROVIDERS[providerId]
+  if (!config) {
+    throw new Error(`Unknown OAuth provider: ${providerId}`)
+  }
+  return config
+}
+
+/**
+ * List all available providers (for frontend)
+ */
+export function listProviders(): OAuthProviderConfig[] {
+  return Object.values(OAUTH_PROVIDERS)
+}

package/src/integrations/oauth/server/credentials.ts

@@ -1,39 +1,43 @@
-/**
- * OAuth Provider Credentials
- * Maps provider IDs to environment variable names
- * Single source of truth for credential lookup
- */
-
-const PROVIDER_ENV_VARS: Record<string, { clientIdEnv: string; clientSecretEnv: string }> = {
-  'google-sheets': {
-    clientIdEnv: 'GOOGLE_OAUTH_CLIENT_ID',
-    clientSecretEnv: 'GOOGLE_OAUTH_CLIENT_SECRET'
-  },
-  dropbox: {
-    clientIdEnv: 'DROPBOX_APP_KEY',
-    clientSecretEnv: 'DROPBOX_APP_SECRET'
-  }
-}
-
-/**
- * Get OAuth client credentials for a provider
- * @throws Error if provider unknown or credentials missing
- */
-export function getOAuthCredentials(providerId: string): { clientId: string; clientSecret: string } {
-  const config = PROVIDER_ENV_VARS[providerId]
-  if (!config) {
-    throw new Error(`Unknown OAuth provider: ${providerId}`)
-  }
-
-  const clientId = process.env[config.clientIdEnv]
-  const clientSecret = process.env[config.clientSecretEnv]
-
-  if (!clientId) {
-    throw new Error(`Missing environment variable: ${config.clientIdEnv}`)
-  }
-  if (!clientSecret) {
-    throw new Error(`Missing environment variable: ${config.clientSecretEnv}`)
-  }
-
-  return { clientId, clientSecret }
-}
+/**
+ * OAuth Provider Credentials
+ * Maps provider IDs to environment variable names
+ * Single source of truth for credential lookup
+ */
+
+const PROVIDER_ENV_VARS: Record<string, { clientIdEnv: string; clientSecretEnv: string }> = {
+  'google-sheets': {
+    clientIdEnv: 'GOOGLE_OAUTH_CLIENT_ID',
+    clientSecretEnv: 'GOOGLE_OAUTH_CLIENT_SECRET'
+  },
+  'google-calendar': {
+    clientIdEnv: 'GOOGLE_OAUTH_CLIENT_ID',
+    clientSecretEnv: 'GOOGLE_OAUTH_CLIENT_SECRET'
+  },
+  dropbox: {
+    clientIdEnv: 'DROPBOX_APP_KEY',
+    clientSecretEnv: 'DROPBOX_APP_SECRET'
+  }
+}
+
+/**
+ * Get OAuth client credentials for a provider
+ * @throws Error if provider unknown or credentials missing
+ */
+export function getOAuthCredentials(providerId: string): { clientId: string; clientSecret: string } {
+  const config = PROVIDER_ENV_VARS[providerId]
+  if (!config) {
+    throw new Error(`Unknown OAuth provider: ${providerId}`)
+  }
+
+  const clientId = process.env[config.clientIdEnv]
+  const clientSecret = process.env[config.clientSecretEnv]
+
+  if (!clientId) {
+    throw new Error(`Missing environment variable: ${config.clientIdEnv}`)
+  }
+  if (!clientSecret) {
+    throw new Error(`Missing environment variable: ${config.clientSecretEnv}`)
+  }
+
+  return { clientId, clientSecret }
+}

package/src/knowledge/__tests__/queries.test.ts

@@ -384,6 +384,95 @@ describe('parsePath — invalid inputs', () => {
   })
 })
 
+// ---------------------------------------------------------------------------
+// parsePath — edge cases
+// ---------------------------------------------------------------------------
+
+describe('parsePath edge cases', () => {
+  // Whitespace handling — the parser does NOT trim the incoming string.
+  // A path with leading whitespace does not start with '/' so it throws.
+  it('throws on path with leading whitespace', () => {
+    expect(() => parsePath(' /by-kind/playbook')).toThrow('parsePath: path must start with "/"')
+  })
+
+  // Trailing whitespace becomes part of the last segment (not stripped).
+  // The segment is non-empty so parsing proceeds and the whitespace is
+  // included verbatim in the returned arg.
+  it('preserves trailing whitespace inside the last segment', () => {
+    const result = parsePath('/by-kind/playbook ')
+    expect(result.mount).toBe('by-kind')
+    expect(result.args[0]).toBe('playbook ')
+  })
+
+  // Multiple trailing slashes are all stripped (regex /\/+$/).
+  it('strips multiple trailing slashes', () => {
+    expect(parsePath('/by-kind/playbook///')).toEqual({ mount: 'by-kind', args: ['playbook'] })
+  })
+
+  // Lone-slash variants — a path of only slashes normalises to an empty
+  // segments list and must throw the root-with-no-mount error.
+  it('throws on path consisting only of slashes', () => {
+    expect(() => parsePath('///')).toThrow('parsePath: path resolves to root with no mount')
+  })
+
+  // Case sensitivity — parsePath does not normalise case.
+  // 'Playbook' (capitalised) is passed through as-is to the caller.
+  it('preserves node-id case (no case normalisation)', () => {
+    // /by-kind takes rest[0] verbatim
+    const result = parsePath('/by-kind/Playbook')
+    expect(result.args[0]).toBe('Playbook')
+  })
+
+  // Feature ID: dot notation passes through unchanged.
+  it('/by-feature/sales.crm preserves dot notation', () => {
+    expect(parsePath('/by-feature/sales.crm')).toEqual({ mount: 'by-feature', args: ['sales.crm'] })
+  })
+
+  // Feature ID: slash notation joins rest segments with '/'.
+  // The parser does NOT convert slashes to dots — the caller must normalise.
+  it('/by-feature/sales/crm joins segments with slash (no dot conversion)', () => {
+    const result = parsePath('/by-feature/sales/crm')
+    expect(result.mount).toBe('by-feature')
+    // args[0] is 'sales/crm', NOT 'sales.crm'
+    expect(result.args[0]).toBe('sales/crm')
+  })
+
+  // /by-kind silently ignores extra path segments beyond the kind argument.
+  it('/by-kind/playbook/extra silently uses only first kind segment', () => {
+    // First segment after 'by-kind' is taken; extra is ignored.
+    const result = parsePath('/by-kind/playbook/extra')
+    expect(result.mount).toBe('by-kind')
+    expect(result.args[0]).toBe('playbook')
+    expect(result.args).toHaveLength(1)
+  })
+
+  // /by-owner joins rest with '/' (same behaviour as /by-feature).
+  it('/by-owner/role.ops-lead/sub joins segments with slash', () => {
+    const result = parsePath('/by-owner/role.ops-lead/sub')
+    expect(result.mount).toBe('by-owner')
+    expect(result.args[0]).toBe('role.ops-lead/sub')
+  })
+
+  // Graph node ID may contain a colon prefix (e.g. knowledge:knowledge.foo).
+  // The parser accepts it — the rest before the verb is joined with '/'.
+  it('/graph/<prefixed-nodeId>/governs round-trips the prefixed id', () => {
+    const result = parsePath('/graph/knowledge:knowledge.test-node/governs')
+    expect(result.mount).toBe('graph')
+    expect(result.args[0]).toBe('knowledge:knowledge.test-node')
+    expect(result.args[1]).toBe('governs')
+  })
+
+  // /graph with no arguments at all (just '/graph').
+  it('throws on /graph with no nodeId or verb', () => {
+    expect(() => parsePath('/graph')).toThrow('/graph requires <nodeId>/<verb>')
+  })
+
+  // /node mount — single-segment path works for any non-reserved first segment.
+  it('single-segment non-reserved path is treated as node mount', () => {
+    expect(parsePath('/knowledge.my-doc')).toEqual({ mount: 'node', args: ['knowledge.my-doc'] })
+  })
+})
+
 // ---------------------------------------------------------------------------
 // formatText
 // ---------------------------------------------------------------------------

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

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest'
 import { buildOrganizationGraph } from '../graph/build'
+import { CAPABILITY_REGISTRY } from '../domains/prospecting'
 import { resolveOrganizationModel } from '../resolve'
 
 describe('organization graph', () => {
@@ -11,7 +12,9 @@ describe('organization graph', () => {
       sourceId: 'sales.crm',
       label: 'CRM'
     })
-    expect(graph.edges.find((edge) => edge.sourceId === 'feature:sales' && edge.targetId === 'feature:sales.crm')).toMatchObject({
+    expect(
+      graph.edges.find((edge) => edge.sourceId === 'feature:sales' && edge.targetId === 'feature:sales.crm')
+    ).toMatchObject({
       kind: 'contains'
     })
   })
@@ -74,9 +77,112 @@ describe('organization graph', () => {
       kind: 'resource',
       label: 'missing-resource'
     })
-    expect(graph.edges.find((edge) => edge.id.includes('uses'))).toMatchObject({
+    expect(graph.edges.find((edge) => edge.kind === 'references' && edge.relationshipType === 'uses')).toMatchObject({
       kind: 'references',
       relationshipType: 'uses'
     })
   })
+
+  it('projects stage nodes from prospecting lifecycle stages', () => {
+    const graph = buildOrganizationGraph({
+      organizationModel: resolveOrganizationModel({
+        features: [{ id: 'operations', label: 'Operations', enabled: true, path: '/operations' }]
+      })
+    })
+
+    const stageNodes = graph.nodes.filter((node) => node.kind === 'stage')
+    expect(stageNodes.length).toBeGreaterThan(0)
+
+    const populated = graph.nodes.find((node) => node.id === 'stage:populated')
+    expect(populated).toMatchObject({ kind: 'stage', sourceId: 'populated' })
+    expect(populated?.label).toBeTruthy()
+
+    expect(graph.edges.find((edge) => edge.kind === 'contains' && edge.targetId === 'stage:populated')).toMatchObject({
+      sourceId: 'organization-model'
+    })
+  })
+
+  it('projects capability nodes from CAPABILITY_REGISTRY with maps_to edges to resources', () => {
+    const graph = buildOrganizationGraph({
+      organizationModel: resolveOrganizationModel({
+        features: [{ id: 'operations', label: 'Operations', enabled: true, path: '/operations' }]
+      })
+    })
+
+    const capabilityNodes = graph.nodes.filter((node) => node.kind === 'capability')
+    expect(capabilityNodes).toHaveLength(CAPABILITY_REGISTRY.length)
+
+    const sample = CAPABILITY_REGISTRY[0]
+    const node = graph.nodes.find((n) => n.id === `capability:${sample.id}`)
+    expect(node).toMatchObject({
+      kind: 'capability',
+      sourceId: sample.id,
+      label: sample.label,
+      description: sample.description
+    })
+
+    expect(
+      graph.edges.find(
+        (edge) =>
+          edge.kind === 'maps_to' &&
+          edge.sourceId === `capability:${sample.id}` &&
+          edge.targetId === `resource:${sample.resourceId}`
+      )
+    ).toBeDefined()
+
+    expect(graph.nodes.find((n) => n.id === `resource:${sample.resourceId}`)).toBeDefined()
+  })
+
+  it('emits uses edges from stages to capabilities for every prospecting build-template step', () => {
+    const model = resolveOrganizationModel({
+      features: [{ id: 'operations', label: 'Operations', enabled: true, path: '/operations' }]
+    })
+    const graph = buildOrganizationGraph({ organizationModel: model })
+
+    for (const template of model.prospecting.buildTemplates) {
+      for (const step of template.steps) {
+        const stageNodeId = `stage:${step.stageKey}`
+        const capNodeId = `capability:${step.capabilityKey}`
+        expect(
+          graph.edges.find(
+            (edge) =>
+              edge.kind === 'uses' &&
+              edge.sourceId === stageNodeId &&
+              edge.targetId === capNodeId &&
+              edge.id.includes(step.id)
+          ),
+          `${template.id}.${step.id}: ${stageNodeId} uses ${capNodeId}`
+        ).toBeDefined()
+      }
+    }
+  })
+
+  it('emits references edges between stages for every step dependsOn link', () => {
+    const model = resolveOrganizationModel({
+      features: [{ id: 'operations', label: 'Operations', enabled: true, path: '/operations' }]
+    })
+    const graph = buildOrganizationGraph({ organizationModel: model })
+
+    for (const template of model.prospecting.buildTemplates) {
+      const stepById = new Map(template.steps.map((s) => [s.id, s]))
+      for (const step of template.steps) {
+        for (const depId of step.dependsOn ?? []) {
+          const depStep = stepById.get(depId)
+          if (!depStep) continue
+          const stageNodeId = `stage:${step.stageKey}`
+          const depStageNodeId = `stage:${depStep.stageKey}`
+          expect(
+            graph.edges.find(
+              (edge) =>
+                edge.kind === 'references' &&
+                edge.sourceId === stageNodeId &&
+                edge.targetId === depStageNodeId &&
+                edge.id.includes(step.id)
+            ),
+            `${template.id}.${step.id} dependsOn ${depId}`
+          ).toBeDefined()
+        }
+      }
+    }
+  })
 })